Externen I2C (F)RAM bequem verwalten

[Embedded Programmer (Gast)]

Hallo,

in einem meiner aktuellen Projekte werden (kleine) Datenmengen 
regelmäßig aktualisiert und sollen halbwegs persistent gespeichert 
werden. Ich habe mich für FRAM entschlossen, welcher mittels I2C von 
meinem AVR (ATmega328p) angesprochen wird.

Teil meines Projekts ist eine I2C Bibliothek sowie eine FRAM Bibliothek, 
welche die Zugriffe etwas abstrahieren. Auf Daten im FRAM kann ich dann 
mit folgenden Funktionen zugreifen:

uint8_t fram_read_byte(uint16_t addr);
void fram_read_block(uint16_t addr, void* dst, size_t len);

void fram_write_byte(uint16_t addr, uint8_t val);
void fram_write_block(uint16_t addr, void* src, size_t len);

Die Adresse ist ja jeweils nur eine Zahl, die sich auf das entsprechende 
Byte im FRAM bezieht. Das funktioniert soweit auch super, nun habe ich 
aber eine eher konzeptuelle Frage. Wie lässt sich der Speicher nun 
bequem mittels C bzw. avr-libc heraus verwalten und darauf zugreifen?

Beispeiseweise möchte ich eine größere Struktur folgender Art im FRAM 
ablegen:

typedef struct {

  char name[64];
  uint16_t impulses;
  uint64_t counter;

} prefs_sub_t;

typedef struct {

  version_t version;
  size_t length;
  prefs_sub_t prefs[256];

} prefs_t;

Insgesamt ist eine konkrete Instanz diesen Typs zu groß, um sie im RAM 
vorzuhalten. Außerdem möchte ich mir den Overhead der korrekten 
"Synchronisation" beider Kopien ersparen. Daher möchte ich die Daten NUR 
(!) im FRAM vorhalten und mittels geeigneter Funktionen bequem auf diese 
zugreifen können.

Allerdings erscheint mir das relativ kompliziert und ich muss händisch 
die jeweiligen Offsets berechnen. Mal angenommen, ich möchte auf den 
Namen des 17. Elements zugreifen, sähe das ja in etwa so aus (vom 
Konzept her, ob es tatsächlich kompiliert weiß ich gar nicht):

char[32] str;
fram_read_block(0 + sizeof(version_t) + sizeof(length) + sizeof(prefs_sub_t) * 17, str, 64);

Das erscheint mir etwas unpraktisch und erfordert wohl viel Rechnerei. 
Vorallem erfordert es Anpassungen, sobald sich die Strukturen einmal 
ändern.

Schöner wäre es, wenn man z.B. ähnlich zum Zugriff auf dem EEPROM einen 
eigenen Pointer-Typ definieren könnte. Ist das denn (ohne tiefgreifende 
Eingriffe in avr-libc bzw. avr-gcc) möglich? Also ein eigenes Attribut 
z.B. FMEM zu definieren (analog zu EEMEM)?

Wie würdet ihr so etwas lösen? Gibt es hier brauchbare Projekte, bei 
denen man sich inspirieren lassen kann? Externen Speicher mittels I2C 
anzusprechen ist ja nicht ganz exotisch, auch wenn es meistens EEPROM 
ist ...

Vielen Dank!

[eagle user (Gast)]

> ich muss händisch die jeweiligen Offsets berechnen

Es gibt neben sizeof auch offsetof(struct_t,member), damit wird es 
kürzer und unempfindlich(er) gegen Änderungen einer struct Definition.

Zweitens könnte man z.B. eine Funktion schreiben, die ein komplettes 
Element prefs_sub_t liefert. Die berechnet dann intern den Offset und 
ruft fram_read_block() auf.

[S. R. (svenska)]

Da deine Struktur nicht in den RAM passt, kannst du immer nur je ein 
Element in der Struktur benutzen. Das ist ein eher schlechter Ansatz.

Du könntest eine Funktion schreiben, die einen Zeiger auf die Struktur 
zurückgibt, wobei das gesuchte Element (also Zeiger + Offset) auf einen 
internen Puffer zeigt, der von der Funktion mit dem passenden Element 
gefüllt wurde. Ein Makro sollte den Elementnamen dann in Offset+Größe 
wandeln können (mit offsetof/sizeof).

Bei jedem Aufruf der Funktion wird dann das zuletzt gelesene Element 
zurückgeschrieben und das neue Element gelesen. Beachte, dass der Zeiger 
selbst ungültig ist!

  struct whatever *mystruct;

  /* lies element1 */
  mystruct = update_cache(element1);
  mystruct->element1 = ...;

  /* schreibe element1, lies element2 */
  mystruct = update_cache(element2);
  mystruct->element2 = ...;

  /* schreibe element2, lies element1 */
  mystruct = update_cache(element1);

[Karol B. (johnpatcher)]

Etwas ähnliches wurde bereits hier [1] diskutiert. Im Wesentlichen 
scheint es zwei Optionen zu geben:

- Adressenrechnerei, welche mittels geeigneter Makros etwas vereinfacht 
werden kann, wie z.B. hier [2] vorgeschlagen:

typedef struct {
  uint8_t  a;
  uint16_t b;
  uint32_t c;
} eeprom_t __attribute__(__packed__);

eeprom_t* eeprom = (eeprom_t*) 0;

uint32_t var = 50;
eeprom_write(&eeprom->c, &var, sizeof(eeprom->c));

- Eigener Adressbereich mit passendem Linkerskript, so wie es hier [3] 
beschrieben wird. Das sieht im einfachsten Fall in etwa so aus:

uint16_t FRAM_Word __attribute__((section(".fram")));
float FRAM_Coeffs[16] __attribute__((section(".fram")));
struct
{
  char name[20];
  float Coeff;
  uint16_t Backup;
} FRAM_Backup __attribute__((section(".fram")));
//...
//...
//...
char name[20];
for(uint8_t x = 0; x < 20; x++)
   name[x] = FRAM_read_byte(&FRAM_Backup.name[x]);

LDFLAGS += -Wl,--section-start=.fram=0x820000

Die zweite Option hat den Vorteil, dass willkürliche Variablen 
"abgelegt" und adressiert werden können ohne mit Adressen bzw. Offsets 
herum rechnen zu müssen. Allerdings hat dieser Ansatz auch Nachteile. 
Pointer sind bei avr-gcc wohl prinzip-bedingt 16 Bit breit, d.h. mehr 
als 65K können nicht addressiert werden. Abhilfe wären verschiedene 
Speicherbereiche, aber das macht es nicht einfacher ...

[1]: Beitrag "ARM-GCC: EEPROM abbilden?"
[2]: Beitrag "Re: ARM-GCC: EEPROM abbilden?"
[3]: 
http://www.avrfreaks.net/forum/how-get-linker-create-new-memory-section