AVR Freaks

uint8_t EEMEM memory[16][14];

	u16 i, j;
	output[0] = target;
	for (i=1, j=0 ; i<=16 ; i++, j++)
	{
		output[i] = eeprom_read_byte(&memory[target][j]);
	} 
	output[18] = '\0';
	USART_printstream(output); // prints the whole array of string

output[i] = eeprom_read_byte(&memory[target][j]); 

note if global interrupts are enabled; you must disable them "cli();" before performing a read; and enable them afterwards; otherwise the mcu will go into reset.

uint16_t EEMEM Eapp = 200;

char s[4]="";
uint16_t temp = 0;
temp = eeprom_read_word(&Eapp);
itoa((signed int)temp,s,4);

#include 
#include 
#include 
#define BUFFER_SIZE 10
#define	BAUD_57600_BPS	15
#define TRUE 1
#define FALSE 0
volatile uint8_t rxBuffer [BUFFER_SIZE];
volatile uint8_t readPtr;
volatile uint8_t writePtr;
volatile uint8_t txComplete;
uint8_t addressWrite EEMEM  = 0;
uint8_t addressRead EEMEM = 0;

//Inizialize USART '0'
void USART_Init (uint16_t data)
{
	/* Set baud rate */
	UBRR0H = (uint8_t)(data>>8);
	UBRR0L = (uint8_t)data;

	//Double Speed Operation
	UCSR0A = 1 << U2X;
   
    //Enable Transmitter and receiver;enable RX interrupt;enable TX interupt
	UCSR0B |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<< TXCIE); 
	
	//Set frame format 8bit
	UCSR0C |= (1<<UCSZ1)|(1<<UCSZ0);
}

void transmitData (uint8_t data)
{	
	UDR0 = data;
}

uint8_t bufferEmpty (void)
{
 	uint8_t emptyFlag;

	emptyFlag = FALSE;

	if(readPtr == writePtr)
	{ 	//buffer is empty
		emptyFlag = TRUE;
	}
	return(emptyFlag);		
}

void writeBuffer (uint8_t data)
{	
	rxBuffer [writePtr] = data;
	writePtr++;

	if (writePtr >= BUFFER_SIZE)
	{
		writePtr = 0;
	}
}

uint8_t readBuffer (void)
{
	uint8_t data;
	data = rxBuffer [readPtr];
	readPtr++;
	
	if (readPtr >= BUFFER_SIZE)
	{	
		readPtr = 0;
	}
	return (data);
}

uint8_t bufferFull (void)
{ 
	uint8_t fullFlag;
	uint8_t tempPtr;
	
	fullFlag = FALSE;
	tempPtr = writePtr;

	if (tempPtr++ >= BUFFER_SIZE)
	{	
		tempPtr = 0;
	}
	if (tempPtr == readPtr)
	{	
		fullFlag = TRUE;
	}

	return (fullFlag);
}

ISR(USART0_TX_vect)
{
	txComplete = TRUE;
} 
	
ISR(USART0_RX_vect)
{  
	if (bufferFull() == FALSE)
	{	
		writeBuffer (UDR0);
	}
}

int main(void)
{
	uint8_t readByte;

	// Initialize transmission complete flag.
	txComplete = TRUE;

	//initialize USART_Init
	USART_Init(BAUD_57600_BPS);
	
 	//Enable Global Interupt
	sei(); 

	// loop forever
	while(1)
	{   
		if (bufferEmpty() == FALSE)
		{	
		//write byte to a EEPROM;location to place the byte;read byte from buffer.
	  		eeprom_write_byte(&addressWrite,readBuffer());
			
         //increament location to next character
			addressWrite++;
			
			if (txComplete == TRUE)
			{	
	     //read previous written character		
            addressRead = addressWrite;
			     
				addressRead--;	

				txComplete = FALSE;
				
           //read byte from EEPROM
				readByte = eeprom_read_byte(&addressWrite);
				
            //transmit to PC what EEPROM read
				transmitData(readByte);
			}
		}
	}
	return 0;	
}    

Ah:

(const void*)&string

This is casting the address of the string pointer to a const void pointer, rather than reinterpreting the pointer's destination type. You are writing the pointer value itself (plus a bunch of other garbage beyond it) to the EEPROM and reading it back, rather than the actual string contents like you desire.

Change the casts to remove the address operator:

(const void*)string

In the read and write calls.

- Dean :twisted:

char *parts[15];
char *last;
char *token;
char **item = parts;

token = strtok_r(cmdlineGetArgStr(1), " ", &last);
while (token) {
	*(item++) = token;
	token = strtok_r(NULL, " ", &last);
}
*item = NULL; 

uint8_t* string = "hello";

eeprom_write_byte((void*)&ee_rdr1_len, strlen(parts[1]));
rprintf("Setting reader1 name to: ");
rprintfStr(parts[1]);
eeprom_write_block((const void*)&parts[1], (void*)&ee_rdr1_name, strlen(parts[1]));

//eeprom_write_byte((void*)&ee_rdr1_len, strlen(string));
//rprintf("Setting reader1 name to: ");
//rprintfStr(string);
//eeprom_write_block((const void*)&string, (void*)&ee_rdr1_name, strlen(string));

If the strings are not null-terminated, strlen() will return an invalid result and you'll get garbage back.

- Dean :twisted:

(const void*)&parts[1]

You're doing it again - remove the "&" sign. In this case, you've got a pointer-to-a-pointer-to-a-char, or interpreted in a different way, an array of strings. When you use the array notation parts[1], you are dereferencing the double pointer once, leaving you with a pointer to the desired string. You need to pass that pointer to the EEPROM functions directly rather than passing it's address.

- Dean :twisted:

The more I read, the less it makes sense. Your parts variable is an array of pointers to char - but you're not actually allocating space for the strings. What you want is something like:

char parts[15][15];

Which will make parts an array of arrays. What you have now is causing the controller to store many bytes into an unallocated space, which is very bad.

Take this example:

char* Test1 = "AAA";
char* Test2;

strcpy(Test2, Test1, strlen(Test1));

Here we have Test2, a raw pointer to unallocated space, and so *any* writes to it's destination will cause data corruption.

A corrected sample would be:

char Test1[] = "AAA";
char Test2[10];

strcpy(Test2, Test1, strlen(Test1));

Which forces Test2 to have a stack allocation of 10 bytes, so we can safely copy strings of up to 9 bytes (the tenth byte is the null terminator) without issue.

- Dean :twisted: