AVRFreaks.net

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

char c;
int n;
long l;
struct {
 char * p;
 int array[10];
} s;

eeprom_read_block((void *)&c, &e_c, 1);
eeprom_read_block((void *)&n, &e_n, 2);
eeprom_read_block((void *)&l, &e_l, 4);
eeprom_read_block((void *)&s, &e_s, 12);

#include <avr/eeprom.h>

uint8_t  EEMEM NonVolatileChar;
uint16_t EEMEM NonVolatileInt;
uint8_t  EEMEM NonVolatileString[10];

int main(void)
{
    uint8_t  SRAMchar;
    uint16_t SRAMint;
    uint8_t  SRAMstring[10];   

    SRAMchar = eeprom_read_byte(&NonVolatileChar);
    SRAMint  = eeprom_read_word(&NonVolatileInt);
    eeprom_read_block((void*)&SRAMstring, (const void*)&NonVolatileString, 10);
}

eeprom_read_block((void*)SRAMstring, (const void*)NonVolatileString, 10);

eeprom_read_block((void*)&SRAMstring[0], (const void*)&NonVolatileString[0], 10);

#include <avr/io.h>
#include <avr/eeprom.h>

uint16_t EEMEM EEint;

int main(void) {
 uint16_t i;
 i = PINC | (PINB << 8); // set it to something useful
 eeprom_write_word(&EEint, i);
}

uint16_t EEMEM Eapp = 200;

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

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#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;   
}