Comment utiliser la Sauvegarde SRAM comme EEPROM dans STM32F4

après avoir lu le Manuel de Référence pour les stm32f4 et la stm32f405xx/stm32f407xx fiche technique je suis d'accord qu'il n'est pas clair comment l'utiliser effectivement la sauvegarde de sram (ou où il est situé). Voici ce que j'ai trouvé. Le CCF de registres et de sauvegarde SRAM contiennent une certaine quantité de stockage est maintenu aussi longtemps que vous avez de la batterie. Le CCF contient 20 registres (80 octets) et la sauvegarde de sram (qui est son propre périphérique sur AHB1 et situé dans le registre de l'adresse de région) contient 0x1000 (4096 octets). Ni sont activées par défaut.

dans DM00037051 (stm32f405xx/stm32f407xx mode feuille de données, p29):

The 4-Kbyte backup SRAM is an EEPROM-like memory area. It can be used to store
data which need to be retained in VBAT and standby mode. This memory area is 
disabled by default to minimize power consumption (see Section 2.2.19: 
Low-power modes). It can be enabled by software.

The backup registers are 32-bit registers used to store 80 bytes of user 
application data when VDD power is not present. Backup registers are not reset
by a system, a power reset, or when the device wakes up from the Standby mode 
(see Section 2.2.19: Low-power modes).

à la page 71 de la feuille de données et p65 du manuel de référence

AHB1   |   0x4002 4000 - 0x4002 4FFF   |   BKPSRAM

et à la page 73 de la datatasheet et p67 du manuel de référence

APB1   |   0x4000 2800 - 0x4000 2BFF   |   RTC & BKP Registers

Page 118-119 du manuel de référence contient des informations sur l'activation de la sauvegarde SRAM et RTC registres.

REMARQUE: si vous utilisez déjà le CCF dans le domaine de sauvegarde et seulement besoin de stocker des <= 80 octets, alors vous êtes mieux d'utiliser le RTC sauvegarde des registres car l'activation de la sauvegarde SRAM seront à peu près le double de la consommation actuelle (voir le tableau 25 dans le stm32f405/7 fiche technique).

voici mon écriture et de lecture fonctions pour la sauvegarde de SRAM et de sauvegarde RTC registres

int8_t write_to_backup_sram( uint8_t *data, uint16_t bytes, uint16_t offset ) {
  const uint16_t backup_size = 0x1000;
  uint8_t* base_addr = (uint8_t *) BKPSRAM_BASE;
  uint16_t i;
  if( bytes + offset >= backup_size ) {
    /* ERROR : the last byte is outside the backup SRAM region */
    return -1;
  }
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
  /* disable backup domain write protection */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);   //set RCC->APB1ENR.pwren
  PWR_BackupAccessCmd(ENABLE);                          //set PWR->CR.dbp = 1;
  /** enable the backup regulator (used to maintain the backup SRAM content in
    * standby and Vbat modes).  NOTE : this bit is not reset when the device
    * wakes up from standby, system reset or power reset. You can check that
    * the backup regulator is ready on PWR->CSR.brr, see rm p144 */
  PWR_BackupRegulatorCmd(ENABLE);     //set PWR->CSR.bre = 1;
  for( i = 0; i < bytes; i++ ) {
    *(base_addr + offset + i) = *(data + i);
  }
  PWR_BackupAccessCmd(DISABLE);                     //reset PWR->CR.dbp = 0;
  return 0;
}

int8_t read_from_backup_sram( uint8_t *data, uint16_t bytes, uint16_t offset ) {
  const uint16_t backup_size = 0x1000;
  uint8_t* base_addr = (uint8_t *) BKPSRAM_BASE;
  uint16_t i;
  if( bytes + offset >= backup_size ) {
    /* ERROR : the last byte is outside the backup SRAM region */
    return -1;
  }
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
  for( i = 0; i < bytes; i++ ) {
    *(data + i) = *(base_addr + offset + i);
  }
  return 0;
}

int8_t write_to_backup_rtc( uint32_t *data, uint16_t bytes, uint16_t offset ) {
  const uint16_t backup_size = 80;
  volatile uint32_t* base_addr = &(RTC->BKP0R);
  uint16_t i;
  if( bytes + offset >= backup_size ) {
    /* ERROR : the last byte is outside the backup SRAM region */
    return -1;
  } else if( offset % 4 || bytes % 4 ) {
    /* ERROR: data start or num bytes are not word aligned */
    return -2;
  } else {
    bytes >>= 2;      /* divide by 4 because writing words */
  }
  /* disable backup domain write protection */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);   //set RCC->APB1ENR.pwren
  PWR_BackupAccessCmd(ENABLE);                          //set PWR->CR.dbp = 1;
  for( i = 0; i < bytes; i++ ) {
    *(base_addr + offset + i) = *(data + i);
  }
  PWR_BackupAccessCmd(DISABLE);                     //reset PWR->CR.dbp = 0;
  //consider also disabling the power peripherial?
  return 0;
}

int8_t read_from_backup_rtc( uint32_t *data, uint16_t bytes, uint16_t offset ) {
  const uint16_t backup_size = 80;
  volatile uint32_t* base_addr = &(RTC->BKP0R);
  uint16_t i;
  if( bytes + offset >= backup_size ) {
    /* ERROR : the last byte is outside the backup SRAM region */
    return -1;
  } else if( offset % 4 || bytes % 4 ) {
    /* ERROR: data start or num bytes are not word aligned */
    return -2;
  } else {
    bytes >>= 2;      /* divide by 4 because writing words */
  }
  /* read should be 32 bit aligned */
  for( i = 0; i < bytes; i++ ) {
    *(data + i) = *(base_addr + offset + i);
  }
  return 0;
}

OriginalL'auteur swinman

Je suis actuellement à l'aide de l'un STM32F2xx microcontrôleur. Selon la fiche technique:

Le 4 kilo-octets de sauvegarde SRAM est une EEPROM-comme la zone.

De conserver le contenu de la CCF de sauvegarde des registres ... quand VDD est éteint, VBAT pin peut être connectée à une option de veille de la tension fournie par une batterie ou par une autre source.

Un supercap, par exemple, serait nécessaire pour maintenir le contenu de la sauvegarde des registres, tandis que le micro-contrôleur est hors tension.

Également, selon le document:

Après la réinitialisation, la sauvegarde de domaine (... sauvegarde SRAM) est protégé contre d'éventuels indésirables accès en écriture. Pour permettre l'accès à la sauvegarde de domaine, procédez comme suit ...

Il vous donne des instructions sur la façon d'accéder à la sauvegarde de domaine directement par écrit à la certains périphériques registre. Si vous avez accès à la STM32F4xx de la bibliothèque, vous pouvez appeler quelque chose comme ceci (note: je suis en utilisant le STM32F2xx bibliothèque):

PWR_BackupAccessCmd(ENABLE);

Remarque: Il est plus que simplement de l'appel de la fonction ci-dessus, telles que l'activation de la sauvegarde d'une mémoire SRAM de l'interface de l'horloge. Consulter le STM32F4 série de la documentation.

Il y a beaucoup de documentation intégrée à la bibliothèque de la source qui est inestimable et si elle est disponible, doit être lu.

Sur le STM32F2 microcontrôleurs de la série, le SRAM est situé à l'adresse mémoire de la gamme:

0x40024000 - 0x40024FFF

Et peut-être écrit quelque part, au lieu, par exemple, comme suit:

#define VAR_LOC ((volatile uint8_t *)(0x40024000))
volatile uint8_t *pVar = VAR_LOC;
*pVar = 5;

OriginalL'auteur Fiddling Bits

Voici l'exemple de HAL bibliothèque pour utiliser la sauvegarde SRAM.

#define  WRITE_READ_ADDR  0x01 //offset value.you can change according to your application
uint32_t write_arr = 0xA5A5A5A6;
uint32_t read_arr;

int main()
{
   enable_backup_sram();
   writeBkpSram(write_arr);
   while(1)
   {
      read_arr = readBkpSram();
   }
}
void enable_backup_sram(void)
{
    /*DBP : Enable access to Backup domain */
    HAL_PWR_EnableBkUpAccess();
    /*PWREN : Enable backup domain access  */
    __HAL_RCC_PWR_CLK_ENABLE();
    /*BRE : Enable backup regulator
      BRR : Wait for backup regulator to stabilize */
    HAL_PWREx_EnableBkUpReg();
   /*DBP : Disable access to Backup domain */
    HAL_PWR_DisableBkUpAccess();
}

void writeBkpSram(uint32_t l_data)
{
   /* Enable clock to BKPSRAM */
  __HAL_RCC_BKPSRAM_CLK_ENABLE();
  /* Pointer write on specific location of backup SRAM */
  (uint32_t *) (BKPSRAM_BASE + WRITE_READ_ADDR) = l_data;
 /* Disable clock to BKPSRAM */
 __HAL_RCC_BKPSRAM_CLK_DISABLE();
}

uint32_t readBkpSram(void)
{
   uint32_t i_retval;

  /* Enable clock to BKPSRAM */
  __HAL_RCC_BKPSRAM_CLK_ENABLE();
  /* Pointer write from specific location of backup SRAM */
  i_retval =  *(uint32_t*) (BKPSRAM_BASE + WRITE_READ_ADDR);
  /* Disable clock to BKPSRAM */
  __HAL_RCC_BKPSRAM_CLK_DISABLE();
  return i_retval;
}

OriginalL'auteur Meera