STM32 Nucleo L476RG SRAM2 Nutzung im Standby Mode

[Christian M. (meiestro)]

Hallo liebe Community,

seit längerem bin ich ein stiller Mitleser hier im Forum und habe hier 
schon oft Lösungen für viele Probleme gefunden.

Heute bin ich auf ein Problem gestoßen, für das ich keine existierenden 
Beiträge gefunden habe:

Ich schicke mein STM32 Nucleo L476 Board in den "Standby" Low Power 
Mode. Laut Ref Manual kann man den SRAM2 beim L476 im Standby Mode 
weiterhin mit Strom versorgen sodass zBsp. Variablen erhalten bleiben. 
Dies mache ich mit der folgenden HAL Funktion und es funktioniert auch:

HAL_PWREx_EnableSRAM2ContentRetention()

Ich habe einen Bereich ".mydata" im Linkerfile angelegt und auf RAM 2 
zugewiesen.

/* My Variables go to RAM2 which is kept during Standby Mode */
.mydata :
{
_smydata = .;         /* define a global symbol at mydata start */
*(.mydata)  
_emydata = .;        /* define a global symbol at mydata end */        
} > RAM2

Die Variable lege ich dann im Bereich ".mydata" an und sie bleibt auch 
nach dem Standby Mode erhalten:

__attribute__ ((section(".mydata"))) volatile uint8_t mD = 0;

Wird der Stecker vom MC gezogen habe ich allerdings Zufällige Werte in 
den Variablen weil der SRAM2 defaultmäßig nicht initialisiert wird.

Ich habe versucht, den Bereich ".mydata" im Startup File 
"startup_stm32l476xx.s folgendermaße zu initialisieren:

LoopCopyDataInit:
  ldr  r0, =_sdata
  ldr  r3, =_edata
  adds  r2, r0, r1
  cmp  r2, r3
  bcc  CopyDataInit
  ldr  r2, =_sbss
  b  LoopFillZerobss

  ldr  r2, =_smydata
  b  LoopFillZeroMyData

/* Zero fill the MyData segment. */
FillZeroMyData:
  movs  r3, #0
  str  r3, [r2], #4

LoopFillZeroMyData:
  ldr  r3, = _emydata
  cmp  r2, r3
  bcc  FillZeroMyData

Hier habe ich eigendlich die Init Funktionen für den bss Bereich 
(FillZerobss und LoopFillZerobss) welche defaultmäßig implementiert sind 
einfach übernommen, weshalb es funktionieren sollte. Zusätzlich habe ich 
in der Funktion

LoopCopyDataInit

die folgenden Zeilen hinzugefügt:

ldr  r2, =_smydata
b  LoopFillZeroMyData

Dies funktioniert jedoch nicht, weil ich immer noch willkürliche Zahlen 
in der Variable habe wenn der MC vom Strom genommen wird.

Außerdem habe ich versucht das ganze über die FLASH option bytes zu 
lösen:


Zu den Konfigurationsmöglichkeiten findet man folgendes im Reference 
Manual S. 108:

Bit 25 SRAM2_RST: SRAM2 Erase when system reset
0: SRAM2 erased when a system reset occurs
1: SRAM2 is not erased when a system reset occurs

Bit 13 nRST_STDBY
0: Reset generated when entering the Standby mode
1: No reset generate when entering the Standby mode

Das Setzen dieser Bits funktioniert erfolgreich (und kann auch über das 
ST-Link-Utility->Target->Option Bytes gemacht werden) allerdings habe 
ich folgende Ergebnisse:

1. SRAM2_RST = 1, nRST_STDBY = 1:  Variable bleibt erhalten aber 
willkürliche Werte nach vom Strom nehmen

2. SRAM2_RST = 0, nRST_STDBY = 1: Varibale bleibt nicht mehr erhalten, 
RAM2 wird somit auch im Standby gelöscht, obwohl ich das nRST_STDBY = 1 
so verstanden hatte das das Reset Flag nicht gestzt wird.

3. nRST_STDBY = 0: Jedes Mal wenn ich den Prozessor in den Standby 
schicke wird automatisch ein Reset durchgeführt, heißt neu gestartet.

Somit habe ich mit den Option Bytes leider nicht das gewünschte 
Ergebniss erhalten.

Hat irgendwer von euch eine Idee, wie ich den RAM2 bei einem 
Reset/Neustart neu Initialisieren- , im Standby Mode jedoch erhalten 
kann?


Mir gehen gerade die Ideen aus wie ich das ganze umsetzen könnte, ich 
wäre für jeden Tipp dankbar!

Das hier ist mein erster aktiver Beitrag hier, ich habe alles nach 
bestem Gewissen hier beschrieben. Sollte etwas nicht passen, dann seit 
bitte nachsichtig mit mir, ich werde es umgehend anpassen!

Grüße,
Chris

[Christopher J. (christopher_j23)]

Da du nur einen Ausschnitt von deinem Startup-Code gepostet hast, bleibt 
mir nur eine grobe Mutmaßung. Folgendes ist ein Auszug aus dem 
Startup-Code eines F411xe aus dem CubeFW Paket. Ich gehe mal davon aus, 
dass der entsprechende Ausschnitt für einen L476 genauso aussieht.

Reset_Handler:  
  ldr   sp, =_estack         /* set stack pointer */
/* Copy the data segment initializers from flash to SRAM */  
  movs  r1, #0
  b  LoopCopyDataInit

CopyDataInit:
  ldr  r3, =_sidata
  ldr  r3, [r3, r1]
  str  r3, [r0, r1]
  adds  r1, r1, #4
    
LoopCopyDataInit:
  ldr  r0, =_sdata
  ldr  r3, =_edata
  adds  r2, r0, r1
  cmp  r2, r3
  bcc  CopyDataInit
  ldr  r2, =_sbss
  b  LoopFillZerobss
/* Zero fill the bss segment. */  
FillZerobss:
  movs  r3, #0
  str  r3, [r2], #4
    
LoopFillZerobss:
  ldr  r3, = _ebss
  cmp  r2, r3
  bcc  FillZerobss

/* Call the clock system intitialization function.*/
  bl  SystemInit
/* Call static constructors */
    bl __libc_init_array
/* Call the application's entry point.*/
  bl  main

Du springst also zunächst zu "LoopCopyDataInit"  und darin dann zu 
"CopyDataInit" zurück, so lange r3 > r2 ist.
Danach geht es weiter in LoopFillZerobss, von wo aus es wieder so lange 
zurück zu "FillZerobss" geht, wie r3 > r2 ist. Wird nicht zurück zu 
"FillZerobss" gesprungen geht es einfach mit dem Aufruf von SystemInit 
und danach mit dem Aufruf von main weiter. Es spielt also keine Rolle, 
was in deiner "LoopCopyDataInit" hinter "b  LoopFillZerobss" steht, weil 
das sowieso nie ausgeführt wird.

Konkret lösen kannst du das Dilemma indem du den folgenden Ausschnitt 
ans Ende von "LoopFillZerobss" setzt, anstatt ans Ende von 
"LoopCopyDataInit":

  ldr  r2, =_smydata
  b  LoopFillZeroMyData

/* Zero fill the MyData segment. */
FillZeroMyData:
  movs  r3, #0
  str  r3, [r2], #4

LoopFillZeroMyData:
  ldr  r3, = _emydata
  cmp  r2, r3
  bcc  FillZeroMyData

Also insgesamt sollte es in etwa so aussehen:

Reset_Handler:  
  ldr   sp, =_estack         /* set stack pointer */
/* Copy the data segment initializers from flash to SRAM */  
  movs  r1, #0
  b  LoopCopyDataInit

CopyDataInit:
  ldr  r3, =_sidata
  ldr  r3, [r3, r1]
  str  r3, [r0, r1]
  adds  r1, r1, #4
    
LoopCopyDataInit:
  ldr  r0, =_sdata
  ldr  r3, =_edata
  adds  r2, r0, r1
  cmp  r2, r3
  bcc  CopyDataInit
  ldr  r2, =_sbss
  b  LoopFillZerobss
/* Zero fill the bss segment. */  
FillZerobss:
  movs  r3, #0
  str  r3, [r2], #4
    
LoopFillZerobss:
  ldr  r3, = _ebss
  cmp  r2, r3
  bcc  FillZerobss
/* Ab hier ist "(Loop-)FillZerobss" fertig */
  ldr  r2, =_smydata
  b  LoopFillZeroMyData

/* Zero fill the MyData segment. */
FillZeroMyData:
  movs  r3, #0
  str  r3, [r2], #4

LoopFillZeroMyData:
  ldr  r3, = _emydata
  cmp  r2, r3
  bcc  FillZeroMyData
/* Ab hier ist "(Loop-)FillZeroMyData" fertig */

/* Call the clock system intitialization function.*/
  bl  SystemInit
/* Call static constructors */
    bl __libc_init_array
/* Call the application's entry point.*/
  bl  main

Noch so als abschließenden Tip:
Mit Hilfe eines Debuggers, den du ja auf dem Nucleo ohnehin drauf hast, 
kannst du so Dinge relativ schnell ausfindig machen. Mal einen 
Breakpoint an der richtigen Stelle setzen und schon siehst du was 
passiert (oder halt auch nicht passiert, wie in diesem Fall).

Christian M. schrieb:
> 1. SRAM2_RST = 1, nRST_STDBY = 1:  Variable bleibt erhalten aber
> willkürliche Werte nach vom Strom nehmen

Mit dieser Variante sollte es dann wie gewünscht funktionieren.

[Christian M. (meiestro)]

Hallo,

erst Mal an Christopher vielen Dank für deine ausführliche Antwort.
Der Startup Code sieht bei mir identisch aus wie bei dir, und mit der 
Änderung funktioniert es auch! Macht Sinn wie du das geschrieben hast, 
da hatte ich einen Fehler.

Nun ist es aber so, dass der ".mydata" Sektor und somit auch meine darin 
abgespeicherten Variablen immer auf Null initialisiert wird, auch wenn 
ich den MC in den Standby schicke und wieder wecke. So wie ich das 
verstanden habe ist der Standby Mode wie ein Reset und der komplette 
Programmcode wird nochmal durchlaufen. Es macht allerdings doch keinen 
Sinn dass man den SRAM2 konfigurieren kann dass der Speicherinhalt nicht 
gelöscht wird es aber nicht möglich ist diesen einmalig zu 
initialisieren?

Bei mir ist es konkret so, dass ich einen Variable für die Menüführung 
meines Programms benutze. Wenn diese beim Startup mit Zufallswerten 
beschrieben ist dann funktioniert das nicht, genauso wenn sie nach jedem 
Wake-Up aus dem Standby Mode wieder auf Null initialisiert wird.

Hatte wer von euch schon ein ähnliches Problem oder steh ich gerade auf 
der Leitung?


Grüße und einen schönen Sonntag,
Chris

[Dr. No (Gast)]

Christian M. schrieb:
> Nun ist es aber so, dass der ".mydata" Sektor und somit auch meine darin
> abgespeicherten Variablen immer auf Null initialisiert wird, auch wenn
> ich den MC in den Standby schicke und wieder wecke. So wie ich das
> verstanden habe ist der Standby Mode wie ein Reset und der komplette
> Programmcode wird nochmal durchlaufen. Es macht allerdings doch keinen
> Sinn dass man den SRAM2 konfigurieren kann dass der Speicherinhalt nicht
> gelöscht wird es aber nicht möglich ist diesen einmalig zu
> initialisieren?


SBF in PWR_CSR checken und entsprechend Initialisierung überspringen.

[Christian Mayer (Gast)]

Vielen Dank für die schnelle Hilfe!
Mit dem SBF-Flag konnte ich es nicht lösen, da es beim Standby Mode 
sowie als auch bei einem Reset gesetzt wird. Durch das Abfragen des 
RCC_FLAG_PINRST Flags konnte ich aber zwischen einem Wake up aus dem 
Standby oder einem Pin Reset unterscheiden!

Viele Grüße,
Chris