xmega eeprom Probleme

[Philip P. (nerb)]

Hi,

ich bin gerade dabei mit dem EEprom der Xmega Serie zu experimentieren.
Als Lib nutze ich die modifizierten Atmel Treiber (siehe Anhang), sowie 
Avr Studio 5 mit GCC und das 128A1 Xplained mit Dragon.

Das Testprogramm schreibt die 3 Zahlen: 12, 25000, 4200000 ins EEprom 
und liest sie anschließend wieder aus und sendet das Ausgelesene per 
USART an den PC.

Hier mein Code:

#define F_CPU 2000000UL

#include <avr/io.h>
#include <util/delay.h>
#include "hardware/usart.h"
#include <avr/eeprom.h>
#include <stdlib.h>
#include <stdio.h>


#include "avr_compiler.h"
#include "eeprom_driver.h"

#define TEST_BYTE_ADDR_1 0x00
#define TEST_BYTE_ADDR_2 0x01
#define TEST_BYTE_ADDR_3 0x05

#define TEST_PAGE_ADDR_1    0  /* Page address always on a page boundary. */
#define TEST_PAGE_ADDR_2    2  /* Page address always on a page boundary. */

 
volatile unsigned char buf1;
volatile unsigned int buf2;
volatile unsigned long int buf3;

void refresh_data(void)
{
  buf1 = eeprom_read8(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1);
  buf2 = eeprom_read16(TEST_PAGE_ADDR_2, TEST_BYTE_ADDR_2);
  buf3 = eeprom_read32(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_3);  
}



int main(void)
{
  char message[64] = {};
  
  EEPROM_EnableMapping();
  
  usartC0_init(9600);
  

  eeprom_write8(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_1, 12);
  eeprom_write16(TEST_PAGE_ADDR_2, TEST_BYTE_ADDR_2, 25000);
  eeprom_write32(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_3, 4200000);


    while(1)
    {
    _delay_ms(1000);
    refresh_data();
    sprintf(message, "buf1: %i  buf2: %u  buf3: %lu \r\n", buf1, buf2, buf3);
    usartC0_puts(message);
    

    }
}

Jetzt zu meinem Problem:

Wenn ich 16- oder 32Bit Variablen auf eine andere Seite als die erste 
schreibe (page != 0x00) dann ist die Speicherzelle leer, wenn ich sie 
wieder lese, das Schreiben (oder das Lesen??) schlägt also fehl. Wenn 
ich hingegen nur 8Bit schreibe, klappt es immer, egal wohin ich das Byte 
schreibe... Hat jemand eine Idee, woran das liegen könnte?


Grüße,
Philip

[Gerhard G. (g_g)]

Hallo,

#include <avr/eeprom.h>
kann bei den Atxmegas nicht verwendet werden.

#include "eeprom_driver.h"
Du hast doch den richtigen Treiber bereits installiert!

EEPROM_WriteByte(..,..,..); Das ist der richtige Befehl.

Sowas gibt es auch zum Lesen.

Schau dir mal den Treiber eeprom_driver.h/eeprom_driver.c an.
Hier findest du die Befehle die auch funktionieren!

Oder aber auch hier:
Beitrag "Xmega EEPROM"

Gruß G.G.

[Philip P. (nerb)]

Hallo,

danke für deine Antwort.

das #include "eeprom_driver.h" stammt noch aus einem vorherigen 
Testversuch, wird aber nicht mehr benutzt. Habe bloß vergessen das aus 
dem Code zu streichen.

Ich benutze den Memory Mapped Modus, da funktioniert diese Funktion 
nicht, die ist nur für den IO-Betrieb. Memory Mapped Modus benutze ich 
wegen des leichteren Zugriffs, die Funktionen für 16- und 32Bit Zugriffe 
fallen wesentlich kleiner aus. Umstellen möchte ich eig. nicht, denn es 
kann ja nicht sein, dass das nicht funktioniert...

Den Beitrag kenne ich und auch diesen Beitrag hier: 
Beitrag "xMega EEPROM Memory-mapped"

Leider funktioniert die "xeeprom.h" überhaupt nicht, ich lese immer nur 
0. Echt zum verrückt werden mit dem Xmega ;)


Grüße,
Philip

[Gerhard G. (g_g)]

Hallo,


Philip P. schrieb:

>> eeprom_write32(TEST_PAGE_ADDR_1, TEST_BYTE_ADDR_3, 4200000);

Wo ist diese Funktion definiert?


Gruß G.G.

[Philip P. (nerb)]

Hallo,

die ist in der "eeprom_driver.h" bzw "eeprom_driver.c" im Anhang. Die 
Lib habe ich um diese Funktionen erweitert, die sind nicht standardmäßig 
drin.

Grüße,
Philip

[Gerhard G. (g_g)]

Hallo,

Philip P. schrieb:
> die ist in der "eeprom_driver.h" bzw "eeprom_driver.c" im Anhang. Die
> Lib habe ich um diese Funktionen erweitert, die sind nicht standardmäßig
> drin.

dann zeig sie uns mal.. hier liegt doch dein Problem!


Gruß G.G.

[Philip P. (nerb)]

Hi,

okay, dann ausgeschrieben:

8bit:

#define EEPROM(_pageAddr, _byteAddr) \
  ((uint8_t *) MAPPED_EEPROM_START)[_pageAddr*EEPROM_PAGE_SIZE + _byteAddr]

uint8_t eeprom_read8( uint8_t pageAddr, uint8_t byteAddr )
{
  EEPROM_WaitForNVM();
  return EEPROM(pageAddr, byteAddr);
}

void eeprom_write8( uint8_t pageAddr, uint8_t byteAddr, uint8_t value )
{
  EEPROM_WaitForNVM();
  EEPROM(pageAddr, byteAddr) = value;
  EEPROM_AtomicWritePage(pageAddr);
}

16bit:

#define EEPROM16(_pageAddr, _byteAddr) \
  ((uint16_t *) MAPPED_EEPROM_START)[_pageAddr*EEPROM_PAGE_SIZE + _byteAddr]

uint16_t eeprom_read16( uint8_t pageAddr, uint8_t byteAddr )
{
  EEPROM_WaitForNVM();
  return EEPROM16(pageAddr, byteAddr);
}

void eeprom_write16( uint8_t pageAddr, uint8_t byteAddr, uint16_t value )
{
  EEPROM_WaitForNVM();
  EEPROM16(pageAddr, byteAddr) = value;
  EEPROM_AtomicWritePage(pageAddr);
}

mit Pageschreibfunktion:

void EEPROM_AtomicWritePage( uint8_t pageAddr )
{
  /* Wait until NVM is not busy. */
  EEPROM_WaitForNVM();

  /* Calculate page address */
  uint16_t address = (uint16_t)(pageAddr*EEPROM_PAGE_SIZE);

  /* Set address. */
  NVM.ADDR0 = address & 0xFF;
  NVM.ADDR1 = (address >> 8) & 0x1F;
  NVM.ADDR2 = 0x00;

  /* Issue EEPROM Atomic Write (Erase&Write) command. */
  NVM.CMD = NVM_CMD_ERASE_WRITE_EEPROM_PAGE_gc;
  NVM_EXEC();
}

Also 8Bit Schreib-/Lesevorgänge gehen auf allen Pages, die 16Bit nur auf 
Page 0. Leider kann ich nicht ganz nachvollziehen, warum das so ist.

Getestet wurde der Code auch auf einem Xmega192A3 (rev.H). Sowohl der 
als auch der Xmega128A1 vom XPlained haben den Hardwarebug:

/*EEPROM page buffer always written when NVM DATA0 is written
If the EEPROM is memory mapped, writing to NVM DATA0 will corrupt data in the EEPROM page buffer.
Problem fix/Workaround
Before writing to NVM DATA0, for example when doing software CRC or flash page buffer
write, check if EEPROM page buffer active loading flag (EELOAD) is set. Do not write NVM
DATA0 when EELOAD is set.*/

Nur schreibe ich nicht auf den Flash, deshalb sollte sich der Fehler 
nicht auswirken. Hat jemand ne Idee?

Grüße,
Philip

[Philip P. (nerb)]

Hallo,

ich habe jetzt die "Lösung" gefunden:

uint16_t eeprom_read16( uint8_t pageAddr, uint8_t byteAddr )
{
  EEPROM_WaitForNVM();
  uint16_t buf;
  buf = (uint16_t)EEPROM(pageAddr, byteAddr) << 8;
  buf +=(uint16_t)EEPROM(pageAddr, ++byteAddr);
  return buf;
}

void eeprom_write16( uint8_t pageAddr, uint8_t byteAddr, uint16_t value )
{
  EEPROM_WaitForNVM();
  EEPROM(pageAddr, byteAddr) = value >> 8;
  EEPROM(pageAddr, ++byteAddr) = value;
  EEPROM_AtomicWritePage(pageAddr);
}

Mit einzelnen 8Bit Zugriffen scheint es also zu funktionieren...
Kann jemand sagen, warumd as so ist?

Grüße,
Philip

[Timmo H. (masterfx)]

G. G. schrieb:
> Hallo,
>
> #include <avr/eeprom.h>
> kann bei den Atxmegas nicht verwendet werden.
Schwachsinn. Benutze ich schon lange beim Xmega. Klappt wunderbar. Ihr 
solltet mal eure Toolchain updaten.
Warum eine eigenen Treiber schreiben wenn alles schon fertig ist?!
Vorallem ist es dann portabel.

[Philip P. (nerb)]

Hi,

das wusste ich nicht. Und damit funktioniert es perfekt... Danke!!

Grüße

[Matthias (Gast)]

Timmo H. schrieb:
>> Hallo,
>>
>> #include <avr/eeprom.h>
>> kann bei den Atxmegas nicht verwendet werden.
> Schwachsinn. Benutze ich schon lange beim Xmega. Klappt wunderbar. Ihr
> solltet mal eure Toolchain updaten.
> Warum eine eigenen Treiber schreiben wenn alles schon fertig ist?!
> Vorallem ist es dann portabel.

Ich würde auch gerne die gewohnten Funktionen aus der eeprom.h für mein 
XMEGA Projekt einsetzen. Allerings bekomme ich vom Compiler unten 
stehende Warnings:

#include <avr/eeprom.h>

#define WERT_LSB 0x00

main()
{
...
 ReadBack = (unsigned int) eeprom_read_byte(WERT_LSB);
...
}

Warnung  1  passing argument 1 of '__eerd_byte_x16a4u' makes pointer 
from integer without a cast [enabled by default]


Meldung  2  expected 'const uint8_t *' but argument is of type 'int'

Bei den Attinys funktionierte das ohne Warnings. AtmelStudio 6.1

Danke für Eure Unterstützung,
Matthias

[Timmo H. (masterfx)]

Matthias schrieb:
> main()
> {
> ...
>  ReadBack = (unsigned int) eeprom_read_byte(WERT_LSB);
> ...
> }
Versuch mal

ReadBack = (unsigned int) eeprom_read_byte((const uint8_t *)WERT_LSB);

Du kannst die Adressen auch von gcc verwalten lassen indem zu EEMEM 
verwendest. Siehe 
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEMEM

[Matthias (Gast)]

Timmo H. schrieb:
> ReadBack = (unsigned int) eeprom_read_byte((const uint8_t *)WERT_LSB);

Danke für den typecast Tipp. Die Warnungen sind weg für diese Funktion.

Leider funktioniert der type cast für die eeprom_write_byte nicht. Siehe 
folgende Funktionsaufruf.

eeprom_write_byte (WERT_LSB_ADR, (uint8_t) WERT_LSB);

Warning  1  passing argument 1 of '__eewr_byte_x16a4u' makes pointer 
from integer without a cast [enabled by default]
Message  2  expected 'uint8_t *' but argument is of type 'int'

Wenn ich den Funktionsaufruf wie folgt anpasse, dann sind zwar für die 
Funktion auch die Warnungen weg, allerdings funktioniert dann das ganze 
Programm nicht mehr.

eeprom_write_byte ((uint8_t *)WERT_LSB_ADR, (uint8_t) WERT_LSB);

Sollte doch eigentlich funktionieren, siehe folgenden 
Funktionsprototypen:

void eeprom_write_byte (uint8_t *__p, uint8_t __value);

Übrigens ich im Kapitel 4.7 vom XMEGA A Manual:
The EEPROM supports both byte and page access.

Vielleicht hat ja jemand noch mal einen Tipp für mich.

Danke schon mal im Vorraus,
Matthias

[Timmo H. (masterfx)]

Wie wärs mit

eeprom_write_byte (((uint8_t *)WERT_LSB_ADR, (uint8_t) WERT_LSB);