32BIT Variable in ATMEGA EEPROM direkt speichern

Manuel K. Gast #431374
Lesenswert?
• ▲
▼ 
Hallo an alles AVR-FREUNDE:

32Bit im EEPROM speichern und auslesen.

hab die klassische EEPROM Routinen für AVR die hier überall im netz 
rumfliegen etwas erweitert.
Diese Routinen können Byte-Weise das interne EEPROM auslesen.
nur blöd dass die meisten daten die man so in einem prog hat, halt 
größer sind als 8Bit ..

nun kann man direkt eine integer variable im EEPROM speichern.
Es kann sowohl eine usigned int , als auch signed gespeichert werden.

viel Spass damit.

Verbesserungsvorschläge &  Fragen jederzeit willkommen.

Gruß, Manuel
Angehängte Dateien:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Karl H. #431598
Lesenswert?
• ▲
▼ 
Hast du dir schon mal die Funktionen angesehen, die mit
dem gcc mitgeliefert werden und in avr/eeprom.h vorhanden sind?

1
uint8_t eeprom_read_byte (const uint8_t *addr);

2
uint16_t eeprom_read_word (const uint16_t *addr);

3
void eeprom_read_block (void *pointer_ram,

4
                        const void *pointer_eeprom,

5
                        size_t size);

6
void eeprom_write_byte (uint8_t *addr,uint8_t value);

7
void eeprom_write_word (uint16_t *addr,uint16_t value);

8
void eeprom_write_block (const void *pointer_ram,

9
                         void *pointer_eeprom,

10
                         size_t size);


  





  

    Antwort Zitieren Bearbeiten Löschen Beitrag melden
  








      

      



  

    

      Karl H.
      

    



    

    
    #431602
  




  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
> void write_32bit_value_(signed int value, unsigned short start_address){
> // beispiel:
> // write_32bit_value_(messwert,0x00);
>
> unsigned char byte[4];
> int i;
> byte[0] = (char) value;
> byte[1] = (char) (value >>8);
> byte[2] = (char) ((value >>8)>>8);
> byte[3] = (char) (((value >>8)>>8)>>8);
>
> for (i=0;i<=4;i++)

Fehler. Du schreibst hier 5 Bytes, nicht 4!
Die Lesefunktion hat den gleichen Fehler. Nur ist er dort
ungleich folgenschwerer. Hier wird nur out-of-bounds gelesen,
in der Leseroutine wird aber out-of-bounds geschrieben.


>   eeprom_write (start_address+i,byte[i]);
>
> }

Das wär auch einfacher gegangen:

1
void write_32bit_value_( unsigned short start_address, signed int value )

2
{

3
  unsigned char i;

4
  unsigned char* tmp = (unsigned char*)&value;

5


6
  for( i = 0; i < sizeof( value ); ++i )

7
    eeprom_write( start_address++, *tmp++);

8
}


oder unter Benutzung der gcc Routinen (am Beispiel von float)

1
void write_float( unsigned short start_address, float value )

2
{

3
  eeprom_write_block( (void*)start_adress, &value, sizeof( value ) );

4
}


  





  

    Antwort Zitieren Bearbeiten Löschen Beitrag melden
  








      

      





      

      






    

    

       Thread beobachten


    

        


Antwort schreiben




  
Bitte melde dich an, um einen Beitrag zu schreiben.

  

  
Bestehender Account



  

    

      

        
        
      

      

        
        
      

    


    

      
      
    




  
oder

  Mit Google-Account einloggen





  
Noch kein Account?

  
Die Registrierung ist kostenlos und dauert nur eine Minute.

  Jetzt registrieren