Arduino Memoire Mesurer

Intro

Une façon de diagnostiquer les problèmes de mémoire est de mesure la quantité de mémoire utilisée.

La Flash

Measuring Flash memory usage is trivial. The compiler does that for you, every time you compile!

Crédit: AdaFruit Industries www.adafruit.com

EEPROM

Vous disposez du contrôle total de l'EEPROM (à 100%). Vous devez lire et écrire chaque byte/octet à une adresse spécifique, il n'y a donc aucune excuse si vous ne savez pas exactement ce que contient cette mémoire. Non vraiment aucune excuse!

// ************************************************
// Ecriture d'une valeur en virgule flottant dans EEPROM
// ************************************************
void EEPROM_writeDouble(int address, double value)
{
  byte* p = (byte*)(void*)&value;
  for (int i = 0; i < sizeof(value); i++)
  {
    EEPROM.write(address++, *p++);
  }
}
    
// ************************************************
// Lecture d'une valeur en virgule flottant depuis EEPROM
// ************************************************
double EEPROM_readDouble(int address)
{
  double value = 0.0;
  byte* p = (byte*)(void*)&value;
  for (int i = 0; i < sizeof(value); i++)
  {
    *p++ = EEPROM.read(address++);
  }
  return value;
}

SRAM

L'utilisation de la SRAM est plus dynamique et par conséquent plus difficile à mmesurer. La fonction free_ram() ci-dessous est une des façon d'y arriver. Vous pouvez ajouter cette définition de fonction dans votre code et ensuite l'appeler depuis différentes partie de votre code pour renvoyer la quantité de mémoire SRAM disponible.

L'utilisation de la SRAM est dynamique et va changer au court du temps. Il est donc important d'appeler free_ram() plusieurs fois depuis différentes place dans le code de votre sketch/croquis pour pouvoir constater son évolution dans le temps.

 int freeRam ()
{
    extern int __heap_start, *__brkval;
    int v;
    return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

Ce que fait free_ram(), c'est retourner l'espace disponible entre la heap (le tas) et la stack (la pile). Elle ne retourne pas la mémoire désallouée ci-et-là dans la heap (tas). L'espace libéré aléatoirement dans la heap n'est pas utilisable par la stack (pile). La heap pourrait être à ce point fragmentée que cet espace ne pourrait pas être réutilisé pour de nombreuses autre demande d'allocation sur la heap. L'espace entre la heap et la stack est vraiment ce que vous devez surveillez si vous essayez d'éviter un crash de la stack.

Crédit: AdaFruit Industries www.adafruit.com Traduction par MCHobby.be

---

Source: Memories of an Arduino. Crédit AdaFruit Industries.

Créé par Bill Earl pour AdaFruit Industries.

Traduit par Meurisse D. pour MCHobby.be

Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.