Atmega32 EEPROM Programming Example

There are two main memory spaces in Atmega32 microcontroller, the Data Memory and the Program Memory space. An additional EEPROM Memory is useful for data storage. It's non-volatile. Hence this controller has three memory space. They are linear and regular.

EEPROM memory space contains up to 1024 bytes of data. It's separated from data space. It's single byte readable and writable. It endurance is up to 100,000 write/erase cycles. Its access time is around 8.5ms for the internal RC clock of 1MHz.

During the device is in power-down sleep mode, the EEPROM write operation still continuous. But it's not completely power down. So the the programmer must verify the EEPROM first before setting the device to entirely power-down mode.

EEPROM corruption can occur whenever the supply voltage is too low, that the instruction execution is incorrect. We can prevent it by enabling the internal Brown-out Detector (BOD). If the BOD can not help ,we can add an additional VCC reset Protection circuit. 

For low level programming like the Assembly language, the programmer must use the I/O and Peripheral Register. However in C programming for the AVR it's invisible for the programmer.

There are some registers that we have to use before accessing the EEPROM memory.

The EEPROM Address Register – EEARH and EEARL

The address register is a 16-bit pair. But it has only 10-bit in use. So it's 10-bit (1024) address. The user can access up to 1024 bytes of EEPROM memory.

The EEPROM Data Register – EEDR

The data register is single byte read/write.

The EEPROM Control
Register – EECR

This memory contains,

• Bits 7..4 – Reserved Bits
• Bit 3 – EERIE: EEPROM Ready Interrupt Enable
• Bit 2 – EEMWE: EEPROM Master Write Enable
• Bit 1 – EEWE: EEPROM Write Enable
• Bit 0 – EERE: EEPROM Read Enable

For AVR Lib-C for AVR device, we don't need to care about these registers. the programmer can use the eeprom.h library, and call its read and write function to access the EEPROM memory.

In this programming example we will use all these registers. The example below will show a simple way to access the internal EEPROM.

Program Simulation

The controller will read and write the internal EEPROM data. The data will display on PortC.

/*
 * m32Eeprom.c
 *
 * Created: 7/20/2022 6:43:00 PM
 * Author : desktop
 */ 
 
#include <avr/io.h>
 
/*Write button connects to PD6*/
#define writeButton ((PIND&0x40)==0)
/*Read button connects to PD7*/
#define readButton ((PIND&0x80)==0)
 
/*EEPROM Write Function*/
void eepromWrite(unsigned int addr,unsigned char dat){
	/*Wait for completion of previous write*/
	while(EECR&(1<<EEWE));
	/*Set up address and data registers*/
	EEAR=addr;
	EEDR=dat;
	/*Write logical 1 to EEMWE*/
	EECR|=(1<<EEMWE);
	/*Start eeprom write by setting EEWE*/
	EECR|=(1<<EEWE);
}
 
/*EEPROM Read Function*/
unsigned char eepromRead(unsigned int addr){
	/*Wait for completion of previous write*/
	while(EECR&(1<<EEWE));
	/*Set up address register*/
	EEAR=addr;
	/*Start eeprom read by writing EERE*/
	EECR|=(1<<EERE);
	/*Return data from data register*/
	return EEDR;
}
 
int main(void)
{
	/*PORTC Output*/
	DDRC=0xFF;
	/*PA0...PA3 Input*/
	DDRA=0xF0;
	/*PORTB Input*/
	DDRB=0x00;
	/*Turn on porta and portb high*/
	PORTA=0x0F;
	PORTB=0xFF;
	/*Turn on PD6 and PD7*/
	PORTD=(1<<6)|(1<<7);
    while (1) 
    {			
		/*eeprom read task*/
		if (readButton)
		{
			/*Wait until the button released*/
			while(readButton);
			PORTC=eepromRead(PINA);
		}
		/*eeprom write task*/
		if (writeButton)
		{
			/*Wait until the button released*/
			while(writeButton);
			eepromWrite(PINA,PINB);
		}
    }
}
 
 

Click here to download its source file.

Schematic

PortA is used for address input. We use only four bits that contain up to 16 addresses.  PortB is used for data input for internal EEPROM writing. Write button connect to PD6 pin while read button connect to PD7 pin. PortC connects to a bar graph LED to display the data reading from internal EEPROM.

 

If you want a standard PCB for ATMega32 micro-controller, you can order my AVR Microcontroller project from PCBWay with a reasonable price. Click here to get a free $5 credit for new account.

Atmega32 Timer/Counter1 in Counter Mode

The Timer/Counter1 module of Atmega32 is able to count external pulse. It has a 16-bit counter/timer registers pair, TCNT1H and TCNT1L. We need to select its clock source of the Timer/Counter1 Control Register B - TCCR1B to allow this module working in external event counting mode. It work in two clock transitions, falling edge and rising edge. The clock source must be point to T1 (PB1) pin.

Running program in Proteus Simulator

It also have a pre-scaler to divide a number of input clock pulse. Basically I will need only the TCCR1B, TCNT1H, and TCNT1L register to make this module operate in external counting mode.

• Timer/Counter1 Control Register B - TCCR1B

Timer/Counter1 Control Register B - TCCR1B

I need to select clock select bits to allow it to work in counter mode, with a rising edge of external clock.

Clock Select Bit Description

I choose the "External clock source on T1 pin. Clock on rising edge". So CS12, CS11, and CS10 will set.

• Timer/Counter1 - TCNT1H and TCNT1L Register 

Timer/Counter1 – TCNT1H and TCNT1L Registers

This register composes of two 8-bit registers pair, TCNT1H and TCNT1L. They are readable and writable.

In this example, I make a counting system that could count up to 10000 before it rolls down. Since this register is 16-bit it maximum value is 65536 values. But it's not necessary here.

/*
 * m32Counter1MuxDisplay.c
 *
 * Created: 7/9/2022 6:10:41 PM
 * Author : aki-technical
 */ 
 
#include <avr/io.h>
 
#define F_CPU 4000000UL
#include <util/delay.h>
 
int main(void)
{
    int temp;
    /*Common Cathode Display*/
    unsigned char displayData[10]={0x3F,0x06,0x5B,0x4F,
0x66,0x6D,0x7D,0x07,0x7F,0x6F};
    /*PortB and PortD Output*/
    DDRC=0xFF;
    DDRD=0xFF;
	/*Select T1 Clock in, rising edge*/
	TCCR1B|=(1<<CS12)|(1<<CS11)|(1<<CS10);
	/*Clear Timer/Counter1*/
	TCNT1H=0;
	TCNT1L=0;
    while (1) 
    {
		/*Read the 16-bit counter registers*/
		temp=(TCNT1H<<8)+TCNT1L;
		/*Reset if it reaches 10000*/
		if (temp>9999)
		{
			temp=0;
			TCNT1H=0;
			TCNT1L=0;
		}
 
		/*Display processing*/
		PORTD=0x00;
		PORTC=displayData[temp/1000];
		PORTD=0x01;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[(temp%1000)/100];
		PORTD=0x02;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[(temp%100)/10];
		PORTD=0x04;
		_delay_ms(5);
 
		PORTD=0x00;
		PORTC=displayData[temp%10];
		PORTD=0x08;
		_delay_ms(5);
    }
}
 
 

 Click here to download its source file.

Schematic

A Simple Two-Wire LCD Programming With Arduino Uno

In this example, I use PCF8574T module that designed for character LCD interfacing. We can solder this module directly with the LCD. However I put either PCF8574T module and the LCD on a single breadboard.

Running program

 The connection between the Arduino Uno and the two-wire display module uses only two communication wires, and two power supply pins.

1. GND
2. +5V (VDD)
3. SCL connects to Arduino pin A5
4. SDA connects to Arduino pin A4

It need the LiquidCrystal_I2C.h file that we need to install it. The program will show a simple text display with a little delay between each characters.

//Two-Wire Library
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
//LCD Setting
LiquidCrystal_I2C lcd(0x27,16,2);
 
void setup(){
  //Initialize the LCD
  lcd.init();
  //Turn on the back light
  lcd.backlight();
  //Blink the cursor
  lcd.blink();
 
  lcdShow("AKI Technical");
  lcd.setCursor(0,1);
  lcdShow("YouTube Channel");
}
 
void lcdShow(char *txt){
  while(*txt){
    lcd.print(*txt++);
    delay(500);
  }
}
 
void loop(){
 
}
 

 Click here to download its source file.

We can use the ATMega32 to control a 3-Wire SPI LCD module (SN74HC595N chip).