Array ins Flash speichern STM32F103VDT6

[Ma B. (drumstick)]

Guten Tag!

Ich arbeite mit dem STM32F103VDT6 und dem uVision von Keil.

Nach einer Lernfahrt möchte ich zwei Arrays mit je 2100 Speicherstellen 
ins Flash ablegen.

    tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  
    tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];

sind in einem Struct verpackt, ich denke die müsste ich aus dem Struct 
nehmen!?

typedef struct  {
                  float motspd_max;     
                  float motspd_cal_max; 
                  float motspd_inc;     
                  float motspd_dec;     
  
                  tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];
                  int MotDistCntVal;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                }
                tSetup;

Ins Flash speichern habe ich auch schon gemacht. Jedoch nur Pageweise. 
Ich kann mir einfach nicht vorstellen, wie man pageübergreifend ins 
Flash speichert!?

Bis Jetzt:

void set_in_Flash(tSetup2 *setup)
{
  
  uint32_t *pData = (uint32_t *)setup;
  uint8_t i;
  int x = (sizeof(tSetup2) / sizeof(int));
  

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR |     FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(FLSHBSEADRPG192);
  
  for(i=0;i<x;i++)
  {
    FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]);
  }
  FLASH_Lock();
}

Kann mir jemand einen Anhaltspunkt geben? Wie schaffe ich es, dass die 
Tabelle (Array) auf zwei Pages aufgeteilt ist!?

Vielen Dank und freundliche Grüsse

M.B.

[Michael B. (michael_b93)]

Wieso berechnest du x durch:

int x = (sizeof(tSetup2) / sizeof(int));

sollte es nicht eher wie folgt sein, wenn du 32bit-Daten auf den Flash 
schreibst?:

int x = (sizeof(tSetup2) / sizeof(uint32_t));

Außerdem kann es dir dabei passieren, dass bei der Anzahl ein Rest 
bleibt, x sollte also ggf. aufgerundet werden, z.B.:

 if ((sizeof(tSetup2) % sizeof(uint32_t) != 0) x++;

In dem Fall solltest du dir aber sinnvoll überlegen womit du das letzte 
Datenwort befüllst, oder du stellst beim auslesen sicher, dass das 
letzte Datenwort nur zum Teil in deine Variable vom Typ tSetup2 
geschrieben wird.

Ansonsten muss ich dir ehrlich sagen, habe ich keine Ahnung was du mit 
"Tabelle auf 2 Pages schreiben" meinst, mit dem von dir obig 
beschriebenen Verfahren schreibst du doch bereits alle Bytes deiner 
Variable setup in den Flash, wieso sollen es genau 2 Pages sein?
Um zu wissen ob das überhaupt geht sollten wir schon wissen wie viele 
Byte tMotorCurrentSample benötigt und wie groß TRAV_MAXDIST_SAMPLES ist.

[Ma B. (drumstick)]

Hallo Michael

TRAV_MAXDIST_SAMPLES = 2100
typedef uint16_t tMotorCurrentSample;

typedef struct  {
                  float motspd_max;     
                  float motspd_cal_max; 
                  float motspd_inc;     
                  float motspd_dec;     
  
                  tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];

                  int MotDistCntVal;
                  float               MotDistCal_pmm;
                  tPIDparameter       PIDpar;
                }
                tSetup;

Der Struct, der ich bis jetzt ins Flash speichere ist nicht grösser als 
2kB also nicht grösser als eine Page.

Die Arrays, die im oben aufgelisteten Struct liegen, sind jetzt grösser 
als eine Page, 2100 * 2 Byte = 4.2 kB

Ich habs kompliziert beschrieben, aber ich muss einfach eine 
Wertetabelle (Array[2100]) ins Flash legen, die grösser ist als eine 
einzelne Page.

Gruss und Danke!

M.B.

[Michael B. (michael_b93)]

Darf ich mal fragen, wo du den Registerwert FLSHBSEADRPG192 her hast? 
Ich kann den gerade nicht definiert finden.

Ansonsten würde ich spontan vermuten, dass die nächste Page bei 
FLSHBSEADRPG192 + 2048 anfängt und wenn du über 2048 Byte schreibst, du 
mit deiner Implementierung sowieso dann auf der nächsten Page landest. 
Oder hast du im Flash nach der Page 192 keine mehr die ungenutzt sind?

Tut mir leid, falls ich es jetzt vielleicht komplizierter mache als 
nötig, aber ich verstehe offenbar noch nicht ganz wo das Problem liegt.

[Ma B. (drumstick)]

// ==== Flash Page Adresses =====
#define FLSHBSEADRPG192 0x0805F800

Ich habe ein Struct der nicht grösser ist als eine Page des Flash und 
speichere diesen in die letzte Page mit der Adresse FLSHBSEADRPG192.

Struct:

typedef struct  {

                  uint8_t             CntCal;
                  int                 ShttrueIdx[CNTSHT];
                  int                 Nmbr_of_Shttr;
                  uint8_t             Nmbr_of_Shttr_part;
                  int                 MotDir;
                  int                 MotDistCal_PulsesMax;
                  int                 MotDistShttrPoints[6];    
                  BOOL                cal_OK;
                }
                tSetup2;

Jetzt habe ich einen weiteren Struct, der ich ins Flash speicheren 
möchte, z.B. in die Page 186.

Struct:

typedef struct  {
                  float motspd_max;       // 4 Byte   
                  float motspd_cal_max;   // 4 Byte
                  float motspd_inc;       // 4 Byte
                  float motspd_dec;       // 4 Byte
   
                  tMotorCurrentSample MotI_TableCW[TRAV_MAXDIST_SAMPLES];  // 4200 Byte
                  tMotorCurrentSample MotI_TableCCW[TRAV_MAXDIST_SAMPLES];  //4200 Byte

                  int MotDistCntVal;        // 4 Byte
                  float               MotDistCal_pmm; // 4 Byte
                  tPIDparameter       PIDpar; // 5 * 4 Byte = 20 Byte
                }
                tSetup;

Dieser Struct ist aber wesentlich grösser (8444 Byte). Eine Page ist 
2000 Byte gross. Also benötigt dieser Struct doch 5 Pages!?

Bis jetzt habe ich aber noch nie einen Struct ins Flash gespeichert, der 
grösser war als eine Page des Flashs.

[Ma B. (drumstick)]

Vielleicht ist ja meine Frage zu einfach für Dich, Michael B. :-)

void set_in_Flash(tSetup2 *setup)
{
  
  uint32_t *pData = (uint32_t *)setup;
  uint8_t i;
  int x = (sizeof(tSetup2) / sizeof(int));
  

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR |     FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(FLSHBSEADRPG192); // Hier lösche ich ja die Page vor dem Beschreiben
   
  for(i=0;i<x;i++)
  {
    FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]);
  }
  FLASH_Lock();
}

Ich könnte auf einmal alle Pages löschen, in die ich schreiben möchte??

void set_in_Flash(tSetup *setup)
{
  
  uint32_t *pData = (uint32_t *)setup;
  uint8_t i;
  int x = (sizeof(tSetup2) / sizeof(int));
  

  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR |     FLASH_FLAG_WRPRTERR);
  FLASH_ErasePage(FLSHBSEADRPG186);
 FLASH_ErasePage(FLSHBSEADRPG187);
 FLASH_ErasePage(FLSHBSEADRPG188);
 FLASH_ErasePage(FLSHBSEADRPG189);
 FLASH_ErasePage(FLSHBSEADRPG190); 
   
  for(i=0;i<x;i++)
  {
    FLASH_ProgramWord(FLSHBSEADRPG192 + i*sizeof(uint32_t), pData[i]);
  }
  FLASH_Lock();
}

[Michael B. (michael_b93)]

Ah ok, jetzt verstehe ich.
Also wenn du keine Folge von Pages zur Verfügung hast auf denen Daten 
frei sind, kann ich dir nur empfehlen etwas zu machen wie:

#define PAGESIZE  2048
for(i=0;i<x;i++)
{
  uint32_t adrs;
  switch (x / PAGESIZE)
  {
    case 0:
      adrs = FLSHBSEADRPG192 + i*sizeof(uint32_t);
      break;
    case 1:
      adrs = FLSHBSEADRPG186 + (i - 1 * PAGESIZE)*sizeof(uint32_t)
      break;
    case 2:
      adrs = FLSHBSEADRPG187 + (i - 2 * PAGESIZE)*sizeof(uint32_t)
      break;

    ...
  }
  FLASH_ProgramWord(adrs, pData[i]);
}

Also indem du dir eine Liste (ggf. etwas intelligenter als Array o.ä.) 
von freien Pages definierst und die dann geeignet auswählst.

Beim Auslesen aus dem Flash und beschreiben in deine Variable vom Typ 
struct solltest du dann natürlich ebenfalls Stückchenweise vorgehen.

Ich hoffe das Hilft dir und ich stehe nicht immer noch auf em Schlauch.

[Michael B. (michael_b93)]

Also alle auf einmal löschen wird wohl nichts, gibt zwar ein 
FLASH_EraseAllPages() - aber das kann auch Pages löschen die du nicht 
löschen willst.

Würde dabei bleiben ein Array von programmierbaren Pages zu definieren 
und dann kannst du ja erst das ganze Array abarbeiten und immer die Page 
löschen und im Anschluss beschreibst du die und nimmst die Adressen zum 
schreiben wiederum aus dem Array.

EDIT:
Für das auslesen aus dem Flash wäre es natürlich günstig bei einer Seite 
zu beginnen und nur die folgenden n Pages zu beschreiben, am besten 
aufeinanderfolgend, dann lässt sich das leichter auslesen weil die 
Registeradressen einfach folgend sind.

[Michael B. (michael_b93)]

Eine Meldung wie: "war doch ganz anders" oder "hab es jetzt hinbekommen 
indem ich ...", oder "ich probiere jetzt noch mal ..." wäre gut, sonst 
machen wir uns nämlich weiter Gedanken wie wir dir helfen können.

[Ma B. (drumstick)]

Hallo!

Bin leider erst jetzt wieder dazu gekommen, um an diesem Projekt zu 
arbeiten. Ich bin mir nicht sicher, ob wir das selbe Problem behandeln!?

Ich weiss, dass die Pages 186 - 190 mir zur Verfügung stehen um den 
Struct, der 8444 Bytes gross ist, darin abzuspeichern. Die Pages liegen 
also nacheinander. Ich weiss jetzt aber nicht wie ich den Struct so 
ablegen kann, dass automatisch, nach dem die Page 186 voll ist auf die 
Page 187 zugegriffen wird. Ich werde Deinen Vorschlag mal ausprobieren. 
Aber da die Pages aneinander liegen benötige ich keine Liste mit 
verfügbaren Pages!?

[Ma B. (drumstick)]

So wies ausschaut hats nicht geklappt....

void set_in_Flash1(tSetup *setup)
{
  #define PAGESIZE  2048
  
  uint32_t *pData = (uint32_t *)setup;
  int i, y;
  int x = (sizeof(tSetup) / sizeof(int));
  
  FLASH_Unlock();
  FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
    
  for(i = 0; i < x ; i++)
  {
    uint32_t adrs;
    
    switch(x / PAGESIZE)
    {
      case 0: adrs = FLSHBSEADRPG186 + i * sizeof(uint32_t);
              break;
      
      case 1: adrs = FLSHBSEADRPG187 + (i - 1 * PAGESIZE) * sizeof(uint32_t); 
              break;
      
      case 2: adrs = FLSHBSEADRPG188 + (i - 2 * PAGESIZE) * sizeof(uint32_t); 
              break;
      
      case 3: adrs = FLSHBSEADRPG189 + (i - 3 * PAGESIZE) * sizeof(uint32_t); 
              break;
      
      case 4: adrs = FLSHBSEADRPG190 + (i - 4 * PAGESIZE) * sizeof(uint32_t); 
              break;
    }
    
    FLASH_ErasePage(adrs);
    FLASH_ProgramWord(adrs, pData[i]);
  }
  FLASH_Lock();
}

Wenn ich im Memory schaue hat er nicht gar nichts geschrieben, aber die 
Werte, die ins Flash geschrieben wurden können nicht stimmen.

Ich frage mich auch, ob ich den erasePage am falschen ort platziert 
habe.

Danke und Gruss

[Ma B. (drumstick)]

Das ErasePage ist def. am falschen ort. So fliegt mir ja das Flash bald 
um die Ohren...

[Michael B. (michael_b93)]

Ja, wenn du die Page nach dem Schreiben löscht ist das falsch. Dann 
löscht du die Page nachdem du das erste Wort geschrieben hast nochmal 
bevor du das 2. schreibst...

Nimm es mal aus der for-Schleife raus und füge eine zusätzliche Schleife 
direkt nach dem ClearFlag ein, in etwa:

#define PAGESIZE  2048
const uint32_t PAGES[]=
{
 FLSHBSEADRPG186
,FLSHBSEADRPG187
,FLSHBSEADRPG188
,FLSHBSEADRPG189
,FLSHBSEADRPG190
};

... // Unlock und Clearflags

for (i=0;i<sizeof(PAGES);i++)
{
  FLASH_ErasePage(PAGES[i]);
}

for(i = 0; i < x ; i++)
{
  const uint32_t adrs = PAGES[i / PAGESIZE] + i * sizeof(uint32_t);
  FLASH_ProgramWord(adrs, pData[i]);
}
FLASH_Lock();

EDIT:
Huch, da war etwas nicht richtig im array-Index.

[Michael B. (michael_b93)]

Ich möchte an dieser Stelle darauf hinweisen, dass ich mir bei:

#define PAGESIZE 2048

nicht sicher bin, vielleicht muss es auch

#define PAGESIZE 2000

sein. Das solltest du anhand vom Manual raus finden: wie viele 32-Bit 
Wörter passen in eine Page.

[Ma B. (drumstick)]

#define FLASH_PAGE_SIZE   0x800

[Michael B. (michael_b93)]

Bist du weiter gekommen?

[Ma B. (drumstick)]

Nein, ich seh nichts im Memory, leider!

[Michael B. (michael_b93)]

Ich hoffe bevor du zu lesen versuchst, gehst du mit z.B.: 
FLASH_GetReadOutProtectionStatus() sicher, dass du überhaupt lesen 
darfst und aktivierst es nötigen falls mit z.B.: 
FLASH_ReadOutProtection(DISABLE)?

[Ma B. (drumstick)]

Ich beobachte das Memory mit dem Debugger

[Michael B. (michael_b93)]

Kann der Debugger anzeigen was im Flash steht? Wäre davon ausgegangen, 
dass das so nicht geht, weiß es aber nicht. Hast du das schon mal 
gemacht oder von jemandem gesagt bekommen, dass im Debugger die Werte 
aus dem Flash übernommen werden?

Im übrigen hast du in deinem letzten größeren Codebeispiel weiterhin:

int x = (sizeof(tSetup) / sizeof(int));

Ist das nun ein Denkfehler von mir gewesen am Anfang, dass es:

int x = (sizeof(tSetup) / sizeof(uint32_t));

heißen müsste? Wenn ja, warum muss es da int sein wenn du in der 
for-Schleife 32-Bit-Int-Weise schreibst?

[Ma B. (drumstick)]

Ja, im Memory View sehe ich was wo abgespeichert wurde.

Bin Deiner Meinung..

int x = (sizeof(tSetup) / sizeof(uint32_t));

ist korrekt!

[Michael B. (michael_b93)]

Hast du mal Interrupts bzgl. Flash aktiviert, wie z.B.: FLASH_IT_ERROR, 
FLASH_IT_EOP und dann geguckt ob der InterruptHandler anspringt?

Wäre mal interessant ob das auftritt, dann würde das heißen, dass das 
schreiben nicht funktioniert (mgl. schreibgeschützte Pages).

[Ma B. (drumstick)]

He jetzt funktioniert es!! Der Interrupt habe ich nicht aktiviert!

Super Danke viel mal!

[Michael B. (michael_b93)]

Das ist schön, Hauptsache es geht jetzt.
Welche Änderungen waren zum Schluss noch nötig?

[Ma B. (drumstick)]

int x = (sizeof(tSetup) / sizeof(uint32_t));

Das uint32_t anstelle int!

Bin aber selber erstaunt, dass dies den Unterschied ausmachte!

nochmals Danke!


Wenn ich auf eine Page des Flashes Zugreiffen möchte:

Setup2 = *((tSetup2*)FLSHBSEADRPG192);

Jetzt kann ich doch einfach die erste Page angeben und es werden alle 
nachfolgenden Pages ausgelesen, oder?

Setup = *((tSetup*)FLSHBSEADRPG186);

Vielen Dank!

Gruss

[Michael B. (michael_b93)]

Glaube schon, dass du das kannst: ich würde nur eher sowas machen wie: 
(ist jetzt nur quick and dirty hingeschrieben)

tSetup2 * tempSetup = (tSetup2*)FLSHBSEADRPG192;
tSetup2 Setup;
memcpy((void*)&Setup,(void*)tempSetup,sizeof(tSetup2));

(Ich fülle Setup quasi "Byteweise" mit den Daten aus dem Flash um 
sicherzugehen, dass ich nicht Bytes nach dem Ende von Setup mit Daten 
aus dem Flash überschreibe.)

Hätte bei mir folgenden Grund: einem Operation wie

Setup = *((tSetup*)FLSHBSEADRPG186);

würde ich selber nicht unbedingt trauen, weil ich mir nicht sicher bin, 
ob der = Operator für dein Struct genau das tut, was man erwartet (in 
deinem Fall, wo du keine Pointer im Struct hast vermutlich kein 
Problem).

Manche Leute würden mich wegen meiner Paranoia vermutlich lünchen und es 
aus Prinzip genau wie von dir vorgeschlagen lösen, weil vermutlich 
schneller und weniger Flash-Lesezugriffe, musst du mal einfach 
ausprobieren, ob es funktioniert, oder du rufst schnell den Lünch-Mob 
;-).

EDIT: Bei Pointern im Struct (als Repräsentanten für dynamisch 
allozierte Variablen) würde auch mein Vorgehen nicht sicher sein, stell 
ich gerade fest... Also vielleicht ignorierst du meine letzte Aussage 
einfach ;)..