Ein Array vom Ram ins Flash bringen

[Tobias B. (horschtx)]

Hallo,
habe mal wieder ein Problemchen...

Ich möchte gerne ein paar größere Daten Arrays ins Flash bekommen. Das 
möchte aber nicht so ganz klappen.

Die Routinen die ich bisher habe sehen so aus.

Eines der Arrays:

uint8_t DM1_DATA_Data_IC_1[DM1_DATA_SIZE_IC_1] = {
0x00, 0xFF, 0x86, 0xCB, 
0xFE, 0x00, 0xF2, 0x6B, 
0x00, 0xFF, 0x86, 0xCB,  
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
};

Der Prototyp:

void Sigma_block_write(uint8_t,uint16_t,uint16_t,uint8_t[]);

Der Aufruf:

Sigma_block_write( DEVICE_ADDR_IC_1, PARAM_ADDR_IC_1, PARAM_SIZE_IC_1, Param_Data_IC_1 );

Die Funktion:

void Sigma_block_write(uint8_t chip,uint16_t adresse,uint16_t length, uint8_t Data[])
{
    PORTE.OUTCLR = PIN4_bm;  
    SPIE.DATA = chip;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    SPIE.DATA = adresse>>8;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    SPIE.DATA = adresse & 0xFF;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    for(uint16_t z=0;z<length;z++)
      {
        SPIE.DATA = Data[z];
        while(!(SPIE.STATUS & SPI_IF_bm))
        dummy = SPIE.DATA;
      }
    PORTE.OUTSET = PIN4_bm;  
    _delay_us(500);
}

Ich habe mal versucht die daten mittels

const uint8_t DM1_DATA_Data_IC_1[DM1_DATA_SIZE_IC_1] PROGMEM = {
0x00, 0xFF, 0x86, 0xCB, 
0xFE, 0x00, 0xF2, 0x6B, 
0x00, 0xFF, 0x86, 0xCB,  
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
};

ins Flash zu schieben... habe noch den Aufruf abgeändert.
Es konnte ohne Fehler Compiliert werden doch wurden falsche Daten 
geschickt.
Irgendwie habe ich da ein Denkfehler.
Vielleicht kann mir jemand weiterhelfen und es an einem Beispiel zeigen.

Vielen Dank.
Gruß Tobias

[Karl H. (kbuchegg)]

Tobias B. schrieb:

> ins Flash zu schieben... habe noch den Aufruf abgeändert.

Wenn du mit PROGMEM arbeitest, reicht das nicht.
Dann müssen auch alle Zugriffe auf die Daten auf die Verwendung von 
pgm_readxxx umgestellt werden.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Flash_mit_PROGMEM_und_pgm_read

[Tobias B. (horschtx)]

Hallo,

danke erstmal für die schnelle Antwort.

Ja das habe ich schon geändert. Aber es will nicht funktionieren.

Hier ist mal der Code wie ich es aktuell versucht habe:

Das Array:

const uint8_t DM1_DATA_Data_IC_1[DM1_DATA_SIZE_IC_1] PROGMEM = {
0x00, 0xFF, 0x86, 0xCB, 
0xFE, 0x00, 0xF2, 0x6B, 
0x00, 0xFF, 0x86, 0xCB,  
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00,  
};

Der Prototyp:

void Sigma_block_write(uint8_t,uint16_t,uint16_t,const uint8_t[]);

Der Aufruf:

Sigma_block_write( DEVICE_ADDR_IC_1, DM1_DATA_ADDR_IC_1, DM1_DATA_SIZE_IC_1, DM1_DATA_Data_IC_1 );

Die Funktion:

void Sigma_block_write(uint8_t chip,uint16_t adresse,uint16_t length, const uint8_t Data[])
{
    PORTE.OUTCLR = PIN4_bm;  
    SPIE.DATA = chip;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    SPIE.DATA = adresse>>8;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    SPIE.DATA = adresse & 0xFF;
    while(!(SPIE.STATUS & SPI_IF_bm))
    dummy = SPIE.DATA;
    for(uint16_t z=0;z<length;z++)
      {
        SPIE.DATA = pgm_read_byte (Data[z]);
        while(!(SPIE.STATUS & SPI_IF_bm))
        dummy = SPIE.DATA;
      }
    PORTE.OUTSET = PIN4_bm;  
    _delay_us(500);
}

So bekomme ich aber falsche Daten. Habe da wohl noch ein Denkfehler 
drin...

[Falk B. (falk)]

@ Tobias B. (horschtx)

>        SPIE.DATA = pgm_read_byte (Data[z]);

Falsch. Eher so

        SPIE.DATA = pgm_read_byte (&Data[z]);

Jaja, Arrays und Pointer sind bei C ein wenig verwirrend ;-)

[Tobias B. (horschtx)]

Ohhh Danke :)

Man man man... so ein blödes &

Da fehlt mir einfach noch die erfahrung und routine dafür

[Falk B. (falk)]

erfahrung & routine

;-)

[traini (Gast)]

Um welchen Controller gehts denn überhaupt?

[Falk B. (falk)]

AVR

[traini (Gast)]

Falk Brunner schrieb:
> AVR

Ach der, der soll ja ganz gut sein, hab ich gehört.

[Tobias B. (horschtx)]

traini schrieb:
> Um welchen Controller gehts denn überhaupt?

Wer es genau Wissen möchte, es ist ein Atmel Xmega 128A1

[Karlo (Gast)]

Nimm _flash anstatt PROGMEM dann klappt alles out-of-the-box.
Musst auch deinen restlichen Code nicht modifizieren.

[Ernie (Gast)]

Karlo schrieb:
> Nimm _flash anstatt PROGMEM dann klappt alles out-of-the-box.
> Musst auch deinen restlichen Code nicht modifizieren.

Gibt es einen fertigen Beispielcode, wie man Daten ins Flash schreiben 
kann, in diesem Thread werden immer nur Andeutungen gemacht.

[Karl H. (kbuchegg)]

?

Weiter oben hab ich einen Link ins Tutorial gepostet. Da drehen sich 
mindestens 5 Bildschirmseiten nur um dieses Thema. In allen Variationen.

[Ernie (Gast)]

Karl Heinz schrieb:
> Weiter oben hab ich einen Link ins Tutorial gepostet. Da drehen sich
> mindestens 5 Bildschirmseiten nur um dieses Thema. In allen Variationen.

Da geht es immer nur darum, wie man Daten aus dem Flash liest, nicht wie 
man Daten zur Laufzeit in den Flash schreibt.

[Karl H. (kbuchegg)]

Ernie schrieb:
> Karl Heinz schrieb:
>> Weiter oben hab ich einen Link ins Tutorial gepostet. Da drehen sich
>> mindestens 5 Bildschirmseiten nur um dieses Thema. In allen Variationen.
>
> Da geht es immer nur darum, wie man Daten aus dem Flash liest, nicht wie
> man Daten zur Laufzeit in den Flash schreibt.

Äh.
Ausser in einem Bootloader - gar nicht.
Das ist ja der ganze Witz an der Harvard Architektur.

[traini (Gast)]

Karl Heinz schrieb:
> Äh.
> Ausser in einem Bootloader - gar nicht.
> Das ist ja der ganze Witz an der Harvard Architektur.

Welchen Teil von "Ein Array vom RAM ins Flash bringen" hab ich dann 
nicht verstanden?

[Karl H. (kbuchegg)]

traini schrieb:
> Karl Heinz schrieb:
>> Äh.
>> Ausser in einem Bootloader - gar nicht.
>> Das ist ja der ganze Witz an der Harvard Architektur.
>
> Welchen Teil von "Ein Array vom RAM ins Flash bringen" hab ich dann
> nicht verstanden?

Dass es darum geht, ein konstantes Array mit konstanten Werten so 
anzulegen, dass es nicht im RAM liegt, sondern vom Compiler im Flash 
angelegt wird.
Von 'zur Laufzeit den Arrayinhalt ändern' ist da nicht die Rede. Der 
Inhalt des Arrays ist zur Laufzeit fix und wird nicht geändert.

[traini (Gast)]

Gibt es dann eine Funktion, die im Bootloader-Bereich platziert wird, 
und Daten zur Laufzeit in den Flash schreiben kann? Es gibt ja auch 
AVRs, die keinen speziellen Bootloader-Bereich haben, da könnte diese 
Funktion ja eigentlich überall stehen?

[Dennis R. (dennis_r93)]

Ich weiß von den stm32f4 Chips, dass der Flash in Blöcken zur Laufzeit 
gelöscht und beschrieben werden kann

Ob das die avrs unterstützen musst du im Datenblatt nachlesen

[Karl H. (kbuchegg)]

traini schrieb:
> Gibt es dann eine Funktion, die im Bootloader-Bereich platziert wird,
> und Daten zur Laufzeit in den Flash schreiben kann? Es gibt ja auch
> AVRs, die keinen speziellen Bootloader-Bereich haben, da könnte diese
> Funktion ja eigentlich überall stehen?

Was genau ist eigentlich das Problem?
AVR sind so ausgelegt, dass
* im Flash das Programms steht (also alles was sich zur Laufzeit nicht 
ändert)
* es ein SRAM für Variablen gibt
* alles was eine Stromabschaltung überleben muss, im EEPROM gespeichert 
wird

AVR gibt es in verschiedenen Ausbaustufen, mit unterschiedlichen Größen 
von Flash, SRAM und EEPROM. Wenn das nicht reicht, kann man für 
Massendaten noch eine SD-Karte anschliessen oder bei manchen auch 
externen Speicher.
Aber eines macht man normalerweise nicht: den Flash über Umwege zum 
Speichern von Werten zu benutzen. Wenn das Speicherangebot nicht reicht, 
dann benutzt du ganz einfach den falschen Prozessor. Dafür sind die AVR 
nicht ausgelegt.

Ja, man könnte den Bootloader Modus ausnutzen. Allerdings ist das mühsam 
und Geschwindigkeitsrekord wirst du damit auch keinen brechen.

[isidor (Gast)]

Dennis R. schrieb:
> Ich weiß von den stm32f4 Chips, dass der Flash in Blöcken zur Laufzeit
> gelöscht und beschrieben werden kann
>
> Ob das die avrs unterstützen musst du im Datenblatt nachlesen

Sollte bei den AVRs eigentlich funktionieren, denn Bootloader ist
ja auch "Laufzeit". Nur - wie du bereits erwähnst - wird das nur
eingeschränkt möglich sein da Flash Speicher immer Page-weise
gelöscht wird. Also müsste ein Array innerhalb einer oder mehrerer
Flash Pages zu liegen kommen und nichts anderes. Nicht sehr
praktikabel .....

[traini (Gast)]

Karl Heinz schrieb:
> AVR gibt es in verschiedenen Ausbaustufen, mit unterschiedlichen Größen
> von Flash, SRAM und EEPROM.

Der EEprom ist im Vergleich zum Flash relativ klein, wenn man mehr Daten 
ablegen will muß man ja nicht gleich einen externen EEprom verwenden.

Würde mich wundern, wenn es noch nie jemand versucht hat, Daten im Flash 
abzulegen.

Im schlimmsten Fall, muß man einen Bootloader umfunktionieren.

[S. R. (svenska)]

traini schrieb:
> Würde mich wundern, wenn es noch nie jemand versucht hat, Daten im Flash
> abzulegen.
Da gibt es bestimmt jemanden. Aber da die Idee, das zur Laufzeit zu 
machen - von ganz bestimmten Sonderfällen mal abgesehen - schlicht dumm 
ist, sind das sicherlich nicht genug.

Die AVRs sind da schlicht das falsche Pferd. Auf dem STM32 gibt es eine 
EEPROM-Emulations-Bibliothek, die den Flash benutzt. Nimm einfach das 
richtige Werkzeug für dein Problem.

[traini (Gast)]

S. R. schrieb:
> Da gibt es bestimmt jemanden. Aber da die Idee, das zur Laufzeit zu
> machen - von ganz bestimmten Sonderfällen mal abgesehen - schlicht dumm
> ist, sind das sicherlich nicht genug.

Der Flash scheint etwas weniger störanfällig als der EEPROM zu sein, man 
könnte also z.B. Kalibrierdaten im Flash ablegen.

[Oliver J. (skriptkiddy)]

Mal als Ergänzung:

/* Locate array[] in flash memory */
const __flash int array[] = { 3, 5, 7, 11, 13, 17, 19 };
     
int i = 1;

int main (void)
{
   /* Return 17 by reading from flash memory */
   return array[array[i]];
}

Quelle: https://gcc.gnu.org/onlinedocs/gcc/Named-Address-Spaces.html

Grüße Oliver

[S. R. (svenska)]

Ja, aber das geht nicht zur Laufzeit (was der TO wollte).
Schöne Grüße übrigens. ;-)

[Oliver J. (skriptkiddy)]

S. R. schrieb:
> Ja, aber das geht nicht zur Laufzeit (was der TO wollte).
> Schöne Grüße übrigens. ;-)

Hab ich ja auch nicht behauptet alter Schwede :) Wollten nur auf das 
"neue" Feature des arv-gcc aufmerksam machen. Damit kann man sich das 
abartige pgm_read*** sparen und der Code wird dadurch überichtilicher. 
Gerade bei im flash abgelegten Strukturen und solchen Sachen. Durfte ich 
gerade selbst bei nem Projekt feststellen.

Grüße vom Chiemsee

[Andreas (Gast)]

Nagelt mich nicht fest, aber ich meine mich zu erinnern, dass das 
Flash-Schreiben bei einigen AVRs direkt aus dem Programm ging, bei dem 
Rest muss es im Bootloader passieren.

Mal abgesehen von dem erhöhtem Flash-Verschleiß ist es auch nicht ganz 
trivial und es ergeben sich ein paar Probleme:
- Die Adresse der Schreibfunktion im Bootloader muß fest und bekannt 
sein, damit man dahin springen kann. Und dann muss man auch noch zurück 
;-)
- Die Adresse der Daten im Flash darf nicht mit dem Programm und 
Booloader kollidieren. Es ist mindestens eine Flashseite groß.
- Man kann die Bytes nicht einzeln speichern, sondern immer alles - 
soviel RAM muss erstmal frei sein.
- const __flash ...{1,2,3..} klappt damit trotzdem nicht

Ich glaube es ist einfacher einen Externen SPI Flash oder EEPROM zu 
benutzen.

[Pete K. (pete77)]

Wenn der Flash nicht zuverlässig ist, tut es vielleicht externes FRAM.

[Peter D. (peda)]

S. R. schrieb:
> Da gibt es bestimmt jemanden. Aber da die Idee, das zur Laufzeit zu
> machen - von ganz bestimmten Sonderfällen mal abgesehen - schlicht dumm
> ist, sind das sicherlich nicht genug.

Das geht prima und ist überhaupt nicht dumm.
Manchmal muß man eben mehr Daten volatile speichern, als der EEPROM 
fassen kann.
In meinem Bootloader ist dazu eine Funktion, die in C aufgerufen werden 
kann.