DIY Electronic Projects And Instruments: AVR

Showing posts with label AVR. Show all posts

Sunday, August 23, 2020

Using ATMega32 Internal EEPROM Memory

Overview

Beside program memory and data memory, the ATMega32 contains up to 1024 bytes of internal EEPROM for auxiliary storage. It can handle up to 100,000 Write/Erase cycles. However its access time is slower than SRAM. Each registers of EEPROM are 8-bit wide unlike the internal program memory that is 16-bit wide. Program memory space is quite larger than EEPROM memory space. In the case of the ATMega32 the program memory is 32K bytes.

It's important to store user's settings data in to this non-volatile memory to prevent data lost next time the MCU turns on, or power interruption. We can also store this type of data in internal program memory (Flash Memory).

Writing And Reading EEPROM Example

The AVR LibC contains the "eeprom.h" library allow us to read and write different kind of data types inside EEPROM such as byte, word, float, etc. Even it's 8-bit wide the library handle this task for the programmers. This library has the following routines,

eeprom_read_byte
eeprom_read_word
eeprom_read_dword
eeprom_read_float
eeprom_read_block

eeprom_write_byte
eeprom_write_word
eeprom_write_dword
eeprom_write_float
eeprom_write_block

and other update routine. For more detail you can see the header file.

For an introductory example, the program will write a set of data of 256 addresses, and read them back.

Writing and Reading EEPROM Example

I use AVR LibC in Microchip Studio.

/*
 * EepromEx1.c
 *
 * Created: 7/20/2023 6:53:22 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#include <avr/eeprom.h>
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
 
int main(void)
{
	DDRC = 0xFF;
	for (uint8_t i= 0;i<0xFF;i++)
		eeprom_write_byte(i,i);
    while (1) 
    {	
		for (uint8_t i = 0; i<0xFF; i++)
		{
			PORTC = eeprom_read_byte(i);
			_delay_ms(250);
		}
 
    }
}

Click here to download its zip file.

Using the EEMEM attribute

EEMEM attribute allow us to declare data on EEPROM space. We can read or write the data using its address. In the following example, I declare a data array on EEPROM first, and then I read those data back.

/*
 * EepromEx2.c
 *
 * Created: 7/20/2023 9:16:24 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
#include <avr/eeprom.h>
 
const uint8_t myData[]  EEMEM = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
 
int main(void)
{
    DDRC=0xFF;
    while (1) 
    {	
		for (int i =0;i<sizeof(myData);i++)
		{
			char temp = &myData[i];
			PORTC=eeprom_read_byte(temp);
			_delay_ms(1000);
		}
 
    }
}

Schematic Diagram

Using the EEMEM attribute

Click here to download its zip file.

Here's another example. I store constant 7-Segment data in EEPROM. The program will read them back and show it on display.

/*
 * EepromEx3.c
 *
 * Created: 7/20/2023 10:17:26 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
#include <avr/eeprom.h>
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
/*Declare EEPROM Storage*/
const uint8_t cCathode[] EEMEM = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,
0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
const  uint8_t cAnode[] EEMEM = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,
0x90,0x88,0x83,0xC6,0xA1,
0x86,0x8E};
 
int main(void)
{
    DDRC=0xFF;
	DDRD=0xFF;
    while (1) 
    {
		for (int i=0;i<sizeof(cCathode);i++)
		{
			PORTD=eeprom_read_byte(&cCathode[i]);
			PORTC=eeprom_read_byte(&cAnode[i]);
			_delay_ms(500);
		}
    }
}

Displaying 7-Segment Data From EEPROM

Click here to download its zip file.

Reading/Writing With Switches and a 7-Segment Display

In this example I use two DIP switches, one for input address while another one for input data that will write data into EEPROM. Input data is between 0 and 0x0F.

Reading/Writing With Switches and a 7-Segment Display

One the SW2 push button is pressed, it will write data from input DSW2 DIP switch with a given address from DSW1 DIP switch.

With any input address change from DSW1, it will read the data from new given address.

/*
 * EepromEx4.c
 *
 * Created: 7/21/2023 9:21:18 AM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
#include <avr/eeprom.h>
 
#define Write (PIND&0x08)==0
#define LED		7
 
/*Declare EEPROM Storage*/
uint8_t Edata[256] EEMEM;
 
const uint8_t cAnode[]  = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E};
 
int main(void)
{
    uint8_t oldAddr=1,newAddr=0,segment=0,inputData;
	DDRA=0x00;
	PINA=0xFF;
	DDRC=0xFF;
	PORTC=0xFF;
	DDRD=0x07;
	PORTD=0xF8;
    while (1) 
    {
		/*Check Address Change*/
		if (newAddr!=oldAddr)
		{
			segment = eeprom_read_byte(&Edata[newAddr]);		
			oldAddr = newAddr;			
		}
	    PORTC = cAnode[segment];
		newAddr = PINA;	
		if (Write)
		{
			PORTC&=~(1<<LED);
			inputData = (PIND&0xF0)>>4;
			eeprom_write_byte(&Edata[newAddr],inputData);		
			while(Write);			
			segment = eeprom_read_byte(&Edata[newAddr]);
			PORTC|=(1<<LED);
		}		
    }
}

Click here to download source file.

The example above use the 7-Segment data that store in SRAM. We can also store and read it from EEPROM.

/*
 * EepromEx5.c
 *
 * Created: 7/21/2023 3:11:48 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
#include <avr/eeprom.h>
 
#define Write (PIND&0x08)==0
#define LED		7
 
/*Declare EEPROM Storage*/
uint8_t Edata[256] EEMEM;
 
uint8_t cAnode[] EEMEM = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E};
 
int main(void)
{
    uint8_t oldAddr=1,newAddr=0,segment=0,inputData,DisplayData=0;
	DDRA=0x00;
	PINA=0xFF;
	DDRC=0xFF;
	PORTC=0xFF;
	DDRD=0x07;
	PORTD=0xF8;
    while (1) 
    {
		/*Check Address Change*/
		if (newAddr!=oldAddr)
		{
			segment = eeprom_read_byte(&Edata[newAddr]);	
			DisplayData = eeprom_read_byte(&cAnode[segment]);		
			oldAddr = newAddr;			
		}
	    PORTC = DisplayData;
		newAddr = PINA;	
		if (Write)
		{
			PORTC&=~(1<<LED);
			inputData = (PIND&0xF0)>>4;
			eeprom_write_byte(&Edata[newAddr],inputData);		
			while(Write);			
			segment = eeprom_read_byte(&Edata[newAddr]);
			DisplayData = eeprom_read_byte(&cAnode[segment]);
			PORTC|=(1<<LED);
		}		
    }
}

Click here to download its source file.

Storing and Reading Data From Flash Memory of ATMega32

ATMega32 contains 32K bytes of internal Flash memory for program storage. The Flash is organized as 16K x 16 because all AVR instructions are 16 or 32 bits wide. For software security, the Flash Program memory space is divided into two sections, Boot Program section and Application Program section.

The Flash Memory has an endurance of at least 10,000 write/erase cycles. The ATMega32 Program Counter (PC) is 14-bit wide, thus addressing the 16K program memory locations.

ATMega32 has 2K bytes of internal SRAM. It's far smaller than its internal Flash. For any situation that the user needs to store a large amount of constant data, it is effective to store and read those data from internal Flash. For example we need to store font data at the amount of 1K bytes. This example project uses a lot of internal SRAM since the program store font and graphic data in SRAM instead of Flash.

The AVR LibC "pgmspace.h" contains routine that declare data into Flash Memory, reading byte data from Flash Memory, etc.

Storing and Reading Data From Flash Memory of ATMega32

Program Simulation

In this example, we store 7-Segments display data in Flash memory. At run-time the program will read 7-Segment data from internal Flash. It will display on a single 7-Segment display connects to PORTC.

/*
 * Example_2.c
 *
 * Created: 7/19/2023 1:52:49 PM
 * Author : Admin
 */ 
 
#include <avr/io.h>
#include <avr/pgmspace.h>
#define F_CPU 8000000UL
#include "util/delay.h"
 
/*Declare constant data that will store in program Flash Memory*/
const char cCathode[] PROGMEM =
 {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
const  char cAnode[] PROGMEM = 
{0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E};
 
int main(void)
{
    DDRC = 0xFF;
    while (1) 
    {
		for (char i=0;i<16;i++)
		{
			/*Read Flash Data and assign to PORTC*/
			PORTC = pgm_read_byte(&cCathode[i]);
			_delay_ms(500);
		}
    }
}

Click here to download its zip file.

ATMega32 Simple Graphical LCD Interfacing Using A 128x64 GLCD

Overview

A graphical LCD can show variety of data including texts, image, symbols, graphic, etc. It usually has an LCD controller inside. A popular LCD controller was KS0108 manufactured by Samsung Electronics. Currently there are many equivalent controller chips. This controller chip was release a few decade ago but it still in use in some small embedded controller projects.

ATMega32 Simple Graphical LCD Interfacing Using A 128x64 GLCD

Sample Program

An example of using this LCD controller chip is a small 128x64 GLCD module. It use a parallel port interface with a few control lines. However some newer equivalent controller chips have an I2C and SPI interface, reducing the number of I/O pins that interface between the LCD and the microprocessor.

Using this type of graphical LCD is very straight forward. Most of electronic hobbyists use Arduino because it's open source, and there are a lot of libraries. CCS PICC compiler for PIC micro-controller also has a library to controller this GLCD. Mikroelectronika have many compilers targeting different type of micro-controllers including PIC, AVR, 8051, ARM, etc. It has many libraries for LCD and graphical LCD including this type. However either CCS PICC and Mikroelectronika's compilers, the user needs to pay for license to get non-restricted access to their compilers.

Microchip Studio (formerly Atmel Studio) is a free IDE from Microchip Technology. We can write the program for Microchip AVR or ARM micro-controller without restriction. For AVR type we can use AVR LIBC that's an open source tool chain.

RT12864J-1 128x64 Graphical LCD

I bought this GLCD module from Ebay many years ago. At that time it was expensive. However it's a low cost now.

Front Panel

Back Panel

Inside this LCD module there are two KS0108 display driver chip, and one KS0107 common driver chip. Since they are chip-on-board we can not see these chips.

RT12864J-1 Datasheet

This module works at +5VDC. It uses the 6800 parallel interface. Command and data are latched into the controller chip at positive transition of Enabel pin (E) between CSA and CSB selection.

Chip Select A (CSA) and Chip Select B (CSB) are active high. we can select one of them, or both.

Data/Instruction (DI) or RS (Register Select pin) is use for choosing between data or instruction code. Data refers to any graphic displaying on screen.

Read or Write (R/W) pin is use for reading or writing data/instruction to LCD controller. We just need to write data to controller. So we must connect it to ground.

Reset (RST) pin is active low signal that will restart the module. We will need to connect it to VCC via a current cutting resistor allowing this module to operate.

Command and sending this LCD is very simple, as it's shown in device data sheet.

The origin of data on screen starts from the upper left corner.

Hardware Interfacing and Programming

I draw and simulate this example program using Proteus 8. This software can simulate the circuit. However the footprint for RT12864J-1 Graphical LCD doesn't exist in this simulator.

Schematic Diagram

I use Microchip Studio IDE to write C codes for this program.

/*
 * RT12864Test4.c
 *
 * Created: 7/15/2023 11:57:20 AM
 * Author : Admin
 */ 
 
#include <avr/io.h>
#include "font5x8.h"
#include "diy-logo.h"
 
#define F_CPU 8000000UL
#include <util/delay.h>
 
#define LCD_DATA PORTC
#define LCD_CONT PORTD
 
#define LCD_EN		0
#define LCD_DI		1
#define LCD_CS1		2
#define LCD_CS2		3
#define LCD_RST		4
 
unsigned char dotCount=0;
 
void lcdCommand(unsigned char cmd,char cs){
	if(cs==1) LCD_CONT|=(1<<LCD_CS1);
	else if(cs==2) LCD_CONT|=(1<<LCD_CS2);
	LCD_CONT&=~(1<<LCD_DI);
	LCD_CONT|=(1<<LCD_EN);
	LCD_DATA=cmd;
	LCD_CONT&=~(1<<LCD_EN);
	_delay_us(10);
	if(cs==1) LCD_CONT&=~(1<<LCD_CS1);
	else if(cs==2) LCD_CONT&=~(1<<LCD_CS2);
}
 
void lcdData(char  data,char cs){
	if(cs==1) LCD_CONT|=(1<<LCD_CS1);
	else if(cs==2) LCD_CONT|=(1<<LCD_CS2);
	LCD_CONT|=(1<<LCD_DI);
	LCD_CONT|=(1<<LCD_EN);
	LCD_DATA=data;
	LCD_CONT&=~(1<<LCD_EN);
	_delay_us(10);
	if(cs==1) LCD_CONT&=~(1<<LCD_CS1);
	else if (cs==2) LCD_CONT&=~(1<<LCD_CS2);
}
 
void lcdHorizontal(unsigned char horizontal){
	lcdCommand(0x40+horizontal,1);
	lcdCommand(0x40+horizontal,2);
 
}
 
void lcdVerticalLine(unsigned char line){
	lcdCommand(0xB8+line,1);
	lcdCommand(0xB8+line,2);
	dotCount=0;
}
 
void lcdSetZ(unsigned char zAxis){
	lcdCommand(0xC0+zAxis,1);
	lcdCommand(0xC0+zAxis,2);
}
 
void lcdXy(unsigned char x,unsigned char y){
	if(x<64){
		lcdCommand(0x40+x,1);
		lcdCommand(0x40+0,2);
	}
	else{
		lcdCommand(0x40+0,1);
		lcdCommand(0x40+x-63,2);
	}
 
	lcdCommand(0xB8+y,1);
	lcdCommand(0xB8+y,2);
	dotCount=x;
}
 
void writeChar(unsigned char aph){
	for (int i=0;i<5;i++)
	{
		if(dotCount<64) lcdData(font5x8[((aph-32)*5)+i],1);
		else lcdData(font5x8[((aph-32)*5)+i],2);
		dotCount++;
	}
	lcdData(0,(dotCount<64)?1:2);
	dotCount++;
	if (dotCount>127)
	{
		dotCount=0;
	}
}
 
void writeCharDelay(unsigned char aph,unsigned int dT){
	for (int i=0;i<5;i++)
	{
		if(dotCount<64) lcdData(font5x8[((aph-32)*5)+i],1);
		else lcdData(font5x8[((aph-32)*5)+i],2);
		if(dT!=0) for(int i=0;i<dT;i++) _delay_us(1000);
		dotCount++;
	}
	lcdData(0,(dotCount<64)?1:2);
	dotCount++;
	if (dotCount>127)
	{
		dotCount=0;
	}
}
 
void lcdString(char *str){
	while(*str)
		writeChar(*str++);
}
 
void writeStringDelay(char *str,unsigned int dT){
	while(*str){		
		if(dT!=0) writeCharDelay(*str++,dT);
		else writeChar(*str++);
	}
}
 
void lcdInit(void){
	DDRC=0xFF;
	DDRD=0xFF;
	/*Display On*/
	lcdCommand(0x3F,1);
	lcdCommand(0x3F,2);
	dotCount = 0;
}
 
void lcdClearScreen(){
 
	for (int i=0;i<8;i++)
	{
		lcdXy(0,i);
		for(int j=0;j<128;j++){
			lcdData(0,1);
			lcdData(0,2);
		}
	}	
	dotCount=0;
	lcdXy(0,0);
}
 
void lcdClearSection(unsigned char x,unsigned char y,unsigned char dot){
	lcdXy(x,y);
	dotCount=x;
	for (int i=0;i<dot;i++)
	{
		if(dotCount<64) lcdData(0,1);
		else lcdData(0,2);
		dotCount++;
	}
 
	if (dotCount>127)
	{
		dotCount=0;
	}
}
 
void showGraphic(void){
	unsigned int kCount=0;
	for (int i=0;i<8;i++)
	{
 
		dotCount=0;
		lcdXy(0,i);
		for (int j=kCount;j<kCount+128;j++)
		{
			if(dotCount<64) lcdData(logo[j],1);
			else lcdData(logo[j],2);
			dotCount++;
		}
		kCount+=128;
	}
}
 
int main(void)
{
	lcdInit();
	lcdClearScreen();
	while (1)
	{
		lcdXy(25,0);
		writeStringDelay("HELLO WORLD!",10);
		lcdXy(0,1);
		writeStringDelay("ATMEGA32 Graphic LCD ",10);
		lcdXy(0,2);
		writeStringDelay("Programming in C With",10);
		lcdXy(0,3);
		writeStringDelay("Microchip Studio",10);
		lcdXy(0,4);
		writeStringDelay("DIY-Instruments",10);
		lcdXy(0,5);
		writeStringDelay("KS0108 LCD Controller",10);
		lcdXy(0,6);
		writeStringDelay("RT12864J-1 128x64",10);
		lcdXy(0,7);
		writeStringDelay("Graphical LCD Module",10);
		_delay_ms(5000);
		lcdClearScreen();
 
		lcdXy(0,0);
		showGraphic();
		_delay_ms(5000);
		lcdClearScreen();
	}
}

Click here to download its source file.

Hardware Testing 1

Hardware Testing 2

Atmega32 Test Board With PICKit2 ICSP

DIY Electronic Projects And Instruments

Pages

Sunday, August 23, 2020

Using ATMega32 Internal EEPROM Memory

Overview

Writing And Reading EEPROM Example

Using the EEMEM attribute

Reading/Writing With Switches and a 7-Segment Display

Storing and Reading Data From Flash Memory of ATMega32

ATMega32 Simple Graphical LCD Interfacing Using A 128x64 GLCD

Overview

RT12864J-1 128x64 Graphical LCD

Hardware Interfacing and Programming

STM32F103R6 DHT-11 Temperature and Humidity Sensor with LCD Example

Pages

Search This Blog