Ch07 AVR Programming in C-1

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. It is easier and less time consuming to
write in C than in Assembly.
2. C is easier to modify and update.
3. You can use code available in function
libraries.
4. C code is portable to other
microcontrollers with little or no
modification.
5. While Assembly language produces a hex
file that is much smaller than C.
6. Programming in Assembly language is often
tedious and time consuming.
7. 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.
ATmega16/mega32 pinout
1. Vital Pins:
1. Power (XCK/T0) PB0 1
40 PIN DIP
40 PA0 (ADC0)
 VCC +5 V
(T1) PB1 2 39 PA1 (ADC1)
(INT2/AIN0) PB2 3 38 PA2 (ADC2)
 Ground (OC0/AIN1) PB3 4 MEGA32 37 PA3 (ADC3)
2. Crystal (SS) PB4

(MOSI) PB5
5
6
36
35
PA4 (ADC4)
PA5 (ADC5)
 XTAL1 (MISO) PB6 7 34 PA6 (ADC6)
+5 V (SCK) PB7 8 33 PA7 (ADC7)
 XTAL2 RESET 9 32 AREF +5 V
3. Reset VCC
GND
10
11
31
30
AGND
AVCC
2. I/O pins XTAL2

XTAL1
12
13
29
28
PC7 (TOSC2)
PC6 (TOSC1)
 PORTA, PORTB, (RXD) PD0
(TXD) PD1
14
15
27
26
PC5 (TDI)
PC4 (TDO)
PORTC, and PORTD (INT0) PD2 16 25 PC3 (TMS)
3. Internal ADC pins (INT1) PD3

(OC1B) PD4
17
18
24
23
PC2 (TCK)
PC1 (SDA)
 AREF, AGND, AVCC (OC1A) PD5
(ICP) PD6
19
20
22
21
PC0 (SCL)
PD7 (OC2)
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 reg-
isters associated with it
 They are designated as
DDRx (Data Direction Reg-
ister), PORTx(Data Reg-
ister), 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.
The structure of IO pinsMega32/Mega16
(XCK/T0) PB0 0 0 0 0 0 0 PA0 (ADC0)
(T1) PB1 1 1 1 1 1 1 PA1 (ADC1)
(INT2/AIN0) PB2 2 2 2 2 2 2 PA2 (ADC2)
(OC0/AIN1) PB3 3 3 3 3 3 3 PA3 (ADC3)
(SS) PB4 4 4 4 4 4 4 PA4 (ADC4)
(MOSI) PB5 5 5 5 5 5 5 PA5 (ADC5)
(MISO) PB6 6 6 6 6 6 6 PA6 (ADC6)
(SCK) PB7 7 7 7 7 7 7 PA7 (ADC7)
DDRA
DDRB
PINB
PORTB
RESET PORTA AREF
PINA
VCC AGND
GND AVCC
XTAL2 PC7 (TOSC2)
XTAL1 PC6 (TOSC1)
(RXD) PD0 PC5 (TDI)
DDRx
(TXD) PD1 PC4 (TDO) 0 1
PORTx
(INT0) PD2 PC3 (TMS)
DDRx.n high impedance
0 (TCK) Out 0
(INT1) PD3 PC2
(OC1B) PD4 PORTx.n 1 (SDA)pull-up
PC1 Out 1
(OC1A) PD5 PC0 (SCL)
(ICP) PD6 PINx.n PD7 (OC2)
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
DDRx: 7 6 5 4 3 2 1 0
PORTx: 7 6 5 4 3 2 1 0
PINx: 7 6 5 4 3 2 1 0
Px7 Px6 Px5 Px4 Px3 Px2 Px1 Px0

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 0’s 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 pins, we
should read the PINx register.
 To send data out to pins we use the PORTx
register .
 There is a pull-up resistor for each of
the AVR pins.
Different States of a Pin in the AVR Microcontroller

DDRx
PORTx
0 1
0 Input & high impedance Out 0
1 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.
int main(void){ //the code starts from here
unsigned char myList[] = "012345ABCD";
unsigned char z;
for(z=0; myList[z]; z++) //repeat 10 times and
increment z
PORTB = myList[z] ; //send the character to PORTB
while(1); //needed if running on a trainer
return 0;
}
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++) // run the next line 200 times
PORTB = ~ PORTB; // toggle PORTB
while(1); // stay here forever
return 0;
}
Example 7-4
// A program to send values of -4 to +4 to Port B.
int main(void){
char mynum[] = {-4,-3,-2,-1,0,+1,+2,+3,+4} ;
unsigned char z;
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.
int main(void){
unsigned int z;
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

int main(void){
unsigned long z; // long is used because it should
// store more than 65535
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.
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){
while(1){
PORTB = 0xAA;
delay100ms() ;
PORTB = 0x55;
delay100ms();
}
return 0;
}
Example 7-8
// Write an AVR C program to toggle all the pins of Port B
// continuously with a 10 ms delay. Use a predefined delay
// function in Win AVR.
// #define F_CPU 4000000UL // for 4 MHz write on top

#include <util/delay.h> //delay loop functions
int main(void){
while(1)
{
PORTB = 0xAA;
_delay_ms(10);
PORTB = 0x55;
_delay_ms(10);
}
return 0;
}
I/O PROGRAMMING IN C: Example 7-9
// LEDs are connected 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;
}
// Write an AVR C program to get a byte of data from Port
// B, and then send it to Port C.

int main(void){
unsigned char temp;
DDRB = 0x00; // Port B is input
DDRC = 0xFF; // Port C is output
while(1){
temp = PINB;
PORTC = temp;
}
return 0;
}
// Write an AVR C program to get a byte of data from
// Port C. If it is less than 100, send it to Port B;
// otherwise, send it to Port D.
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.
int main(void) {
DDRA = 0xFF; //make Port A output
DDRB = 0xFF; //make Port B output
DDRC = 0xFF; //make Port C output
DDRD = 0xFF; //make Port D output
PORTA = 0x35 & 0x0F; // bitwise AND
PORTB = 0x04 | 0x68; // bitwise OR
PORTC = 0x54 ^ 0xF0; // bitwise XOR
PORTD = ~ 0x55; // bitwise NOT
while(1);
return 0;
}
// Write an AVR C program to toggle only bit 4 of
Port B
// continuously without disturbing the rest of the
pins of
// Port B.
int main(void)
{
while(1)
{
PORTB = PORTB ^ 0b00010000;
//set bit 4 (5th bit) of PORTB
}
return 0;
}
// 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.
int main(void){
DDRC = 0x00; // PORTC is input
while(1){
if (PINC & 0b00100000) // check bit 5 (6th bit)
// of PINC
PORTB = 0x55;
else
PORTB = 0xAA;
}
return 0;
}
// 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.
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;
}
// 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.
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
// Write an AVR C program to read pins 1 and 0 of Port B
// and issue an ASCII character to Port D
int main(void){
unsigned char z;
DDRB = DDRB & 0b11111100 ; // 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 0
}
}
return 0;
}
// Write an AVR C program to monitor bit 7 of Port B. If
// it is 1 make bit 4 of Port B input; otherwise, change
// pin 4 of Port B to output.

int main(void){
DDRB = DDRB & 0b01111111; //bit 7 of Port B is input
// DDRB &= 0b01111111;
while (1){
if(PINB & 0b10000000)
//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;
}
// 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.
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;
}
// Write an AVR C program to toggle all the pins of
// Port B continuously.
int main(void){
DDRB = 0xFF; // Port B is output
PORTB = 0xAA;
while(1)
{ PORTB = ~ PORTB; } // toggle PORTB
return 0;
}

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.
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;
}
// 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.
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;
}
// 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.
#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.
int main(void){
unsigned char x, y;
unsigned char mybyte = 0x29;
DDRB = DDRC = 0xFF; // make Ports B and C output
x = mybyte & 0x0F; // mask upper 4 bits
PORTB = x | 0x30; // make it ASCII
y = mybyte & 0xF0; // mask lower 4 bits
y = y >> 4; // shift it to lower 4 bits
PORTC = y | 0x30; // make it ASCII
while(1); // stay here
return 0;
}
//Write an AVR C program to convert ASCII digits of '4‘
// and '7' to packed BCD and display them on PORTB.
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;
}
Data Conversion Programs in C: Exercise
// Write an AVR C program to take two BCD numbers 0x74
// from PORTC. Swap these numbers to 0x74 and show the
// result on PORTC
int main(void){
unsigned char c,d,e;
DDRC = 0x00; // PORTC is input port
DDRB = 0xFF; // PORTB is output port
while(1){
c = PINC; // take input 0x74
d = c & 0x0F; // d = 0x04
e = c & 0xF0; // e = 0x70
d = d << 4; // d = 0x40
e = e >> 4; // d = 0x07
PORTB = d|e; // PORTB = 0x47
}
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.
Checksum byte Calculation 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;
}
Checksum byte Verification in C: Example 7-30
// Write a C program to perform step (b) of Example 7-28.
// If the data is good, send ASCII character 'G' to PORTD.
// Otherwise, send 'B' to PORTD.
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;
}
// Write an AVR C program to convert 11111101 (FD hex) to
// decimal and display the digits on PORTB, PORTC, PORTD.
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 Converts the integer n to
*str) characters in string str
void ltoa(int n, char Converts the long n to
*str) 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 Micro-
controllers 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 16-
bit 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 EEAR.
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
Bit 15 14 13 12 11 10 9 8
EEARH - - - - - - EEAR9 EEAR8
EEARL EEAR7 EEAR6 EEAR5 EEAR4 EEAR3 EEAR2 EEAR1 EEAR0
Bit 7 6 5 4 3 2 1 0
Figure 6-15: EEPROM Address Register
 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.
EECR - - - - EERIE EEMWE EEWE EERE
Bit 7 6 5 4 3 2 1 0
Figure 6-16: EEPROM Control Register
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. In 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 step 2 and 3 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.
void EEPROM_write(unsigned int Address, unsigned char Data){
// Wait for completion of previous write
while(EECR & (1<<EEWE));
// Set up address and data registers
EEAR = Address; EEDR = Data;
// Write logical one to EEMWE
EECR |= (1<<EEMWE);
// Start eeprom write by setting EEWE
EECR |= (1<<EEWE);
} int main(void){
EEPROM_write(0x5F, 'a'); 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.

unsigned char EEPROM_read(unsigned int Address){
// Set up address register
EEAR = Address;
// Start eeprom read by writing EERE
EECR |= (1<<EERE);
// Return data from data register
return EEDR;
}
int main(void){
DDRB = 0xFF;
PORTB = EEPROM_read(0x5F);
while(1);
return 0;
}
Reading and Writing EEPROM in C (1/2)
// Write an AVR C program to store ‘a' into location
// Ox005F of EEPROM then read from EEPROM.

void EEPROM_write
(unsigned int Address, unsigned char Data)
{
// Set up address and data registers
EEAR = Address; EEDR = Data;
// Write logical one to EEMWE
EECR |= (1<<EEMWE);
// Start eeprom write by setting EEWE
EECR |= (1<<EEWE);
}
unsigned char EEPROM_read(unsigned int Address)
{
Reading and Writing EEPROM in C (2/2)
// Set up address register
EEAR = Address;
// Start eeprom read by writing EERE

EECR |= (1<<EERE);
// Return data from data register

return EEDR;
}
int main(void){
unsigned char data = 0x33;
DDRB = 0xFF;
EEPROM_write(0x5F, 'a');
data = EEPROM_read(0x5F);
PORTB = data;
while(1);
return 0;
}
Writing a String on EEPROM
int main(void)
{
unsigned char i;
unsigned char msg[] = "IIUI ISB";
DDRB = 0xFF;
for(i=0 ; msg[i] ; i++)
EEPROM_write(i, msg[i]);
EEPROM_write(i, 0); // Write NULL
PORTB = 0x55;
while(1);
return 0;
}

Ch07 AVR Programming in C-1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ch07 AVR Programming in C-1

Uploaded by

Copyright:

Available Formats

Embedded Systems

Engr. Rashid Farid Chishti

Chapter 07: AVR Programming in C

International Islamic University H-10, Islamabad, Pakistan

#include <avr/io.h> //standard AVR header

// Notice that the program never exits the for

2. Crystal (SS) PB4

2. I/O pins XTAL2

3. Internal ADC pins (INT1) PD3

Px7 Px6 Px5 Px4 Px3 Px2 Px1 Px0

Different States of a Pin in the AVR Microcontroller

activate the internal pull-up resistor

deactivate or turn off the internal pull-up

#include <avr/io.h> // standard AVR header

#include <avr/io.h> // standard AVR header

void delay100ms(void){ // try different numbers on your

// #define F_CPU 4000000UL // for 4 MHz write on top

#include <avr/io.h> // standard AVR header

#include <avr/io.h> //standard AVR header

#include <avr/io.h> // standard AVR header

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

 EEDR (EEPROM Data Register)

 EEARH-EEARL (EEPROM Address Register High-Low)

 EEPROM Data Register (EEDR)

EEARL EEAR7 EEAR6 EEAR5 EEAR4 EEAR3 EEAR2 EEAR1 EEAR0

 EEPROM Control Register (EECR)

EECR - - - - EERIE EEMWE EEWE EERE

#include <avr/io.h> //standard AVR header

#include <avr/io.h> //standard AVR header

// Start eeprom read by writing EERE

// Return data from data register

You might also like