AVR Freaks

Etot = 12657;
Es_month = 345;
Ew_month = 789;

12657345789

Etot = 12657;
Es_month = 3456;
Ew_month = 789;

26573456789

Etot = 12657;
Es_month = 345;
Ew_month = 7896;

126573457896

Etot = 1265;
Es_month = 3456;
Ew_month = 789;

2653456789

Etot = 1265;
Es_month = 34;
Ew_month = 789;

126534789

Remember that in C a zero byte is treated as a null-terminator -- if you have junk data in the first 10 bytes of the string, chances are one might be a terminator which will stop any display of the buffer contents before the contents of the EEPROM read string is reached.

You need to read/write one more byte to EEPROM than there are characters in the string -- there's a hidden 0x00 byte at the end of each string which terminates it. Without the terminator, your string routines will become confused.

A string defined as [5] can hold 4 digits and the terminating 0x00. A string defined as [4] can hold just 3 digits and the 0x00.

abcminiuser wrote:

(...)

At the moment, we now have access to the eeprom memory, via the routines now provided by eeprom.h. There are three main types of EEPROM access: byte, word and block. Each type has both a write and a read variant, for obvious reasons. The names of the routines exposed by our new headers are:

Quote:

(...)
� void eeprom_read_block (void *pointer_ram, const void *pointer_eeprom, size_t n)
� void eeprom_write_block (const void *pointer_ram, void *pointer_eeprom, size_t n)

(...)

I think you've got the two first arguments to eeprom_write_block in the wrong order.

From eeprom.h:

Quote:

static __inline__ void
eeprom_write_block (void *__dst, const void *__src, size_t __n)

Davef,

Damnit, yet another typo. That should indeed be read_word - I'll go fix that now. Amazing that anyone still bothers to read my tutorials with all these silly mistakes!

Quote:

In , eeprom_read_byte and eeprom_write_byte use a u08 pointer for the address. Doesn't this mean you can only access 256 bytes in the EEPROM? What about the remaining 1024-256 = 968 EEPROM bytes in a ATmega32?

That tripped me up too at the start. In AVR-GCC, all pointers are an int in size, two bytes. The pointer typecast only specifies what type of data the pointer is pointing to, not the pointer's size. A (uint8_t*), (uint16_t*) and (uint32_t*) are all identical in size, they just point to increasingly larger datatypes.

For example, (uint8_t*)0x1234 is a pointer two bytes in size, pointing to a byte at the location 0x1234.

This is a problem when dealing with pointers to the AVR's flash memory, since in some AVRs this overflows an int. Because of this, pointers to flash addresses are still two bytes in size but the pointer is word rather than byte aligned, so an increase of one in the pointer's address corresponds to a jump of two bytes.

If I can think of enough material for this I might make it into a short tutorial since it seems to be such a prevalent issue.

- Dean :twisted:

typedef struct INNER_STRUCT1 {
  uint8_t var1;  
  uint8_t var2;
  int8_t  var3;
} innerStruct1_t;

typedef struct INNER_STRUCT2 {
  uint8_t var1;  
  uint8_t var2;
  int8_t  var3;
} innerStruct2_t;

typedef struct OUTER_STRUCT {
  uint8_t        outerVar1;
  uint8_t        outerVar1;
  uint8_t        outerVar1;  
  innerStruct1   innerVars1[5];
  innerStruct2   innerVars2[5];
} outerVars_t;

outerVars_t   EEMEM   EE_Vars = {22,100,12,?help;

EEMEM char ok_test[] = "Test Ok!\n\r";
EEMEM char copy_right[]="8-bit Test device super puper multi pulti, C 2012 Vr.SuperWriter";

void SendStr(char *string)
{
while (*string!='\0')	/
	{
	SendByte(*string);		
	string++;		/
	}			
}

void SendByte(char byte)		
{
while(!(UCSRA & (1<<UDRE)));	
UDR=byte;			
}
int main(void)
{
	USART_Init(51);
	char *u;
        string[]=""
	u=string;

	eeprom_read_block(u,ok_test,sizeof(ok_test));
	SendStr(u);
        eeprom_read_block(u,copy_right,sizeof(copy_right));
	SendStr(u);
	

while (eeprom_read_byte(string) != '\0')

	eeprom_read_block ((void *)&Array, (const void *)ArrayEE, sizeof ArrayEE[0]);
	eeprom_read_block ((void *)&Value, (const void *)&ValueEE, sizeof ValueEE[0]);

for(i=0;i<13;i++)
{
	for(j=0;j<13;j++)
	{
		if((i==j))
		{
			SetAbsPos(101,0);
			switch(Array[i])
			{
				case 1:
					SetSpeed(0,100,101);
					MotorStart(1,0,0);
					_delay_ms(100);
					GetAbsPos(101,&Motor1AbsPos);
					while(Motor1AbsPos<=Value[j])
					{
						
						SetAbsPos(101,Motor1AbsPos);
						_delay_ms(100);
						GetAbsPos(101,&Motor1AbsPos);
					}
					break;

#include
#include 
long Value[13];
int EEMEM ArrayEE[13];
long EEMEM ValueEE[13];
int Array [13];
int main()
{
/*
do{
	senzor=Senzori();
	Array[k]=senzor;
switch (senzor)
{

}//switch
}while(senzor!=5);
	eeprom_update_block ((const void *)&Array, (void *)&ArrayEE, 13);
	eeprom_update_block ((const void *)&Value, (void *)&ValueEE, 13);
_delay_ms(10);
*/
uint16_t Red;
uint32_t Vrednost;
for(i=0;i<13;i++)
{
Red=eeprom_read_word ((const uint16_t *)&ArrayEE[i]);
Vrednost= eeprom_read_dword ((const uint32_t *)&ValueEE[i]);
	
	switch (Red)
	{
	}// switch
while(1);
}//main