Arduino Memoire Mesurer - Historique des versions

Admin : /* SRAM */

2013-08-31T19:10:00Z

SRAM

Admin : /* EEPROM */

2013-08-31T18:55:13Z

EEPROM

Admin : /* Intro */

2013-08-31T18:50:23Z

Intro

Admin : /* Intro */

2013-08-31T18:50:02Z

Intro

Admin : /* SRAM */

2013-08-31T10:40:35Z

SRAM

Admin : Page créée avec « {{Arduino-Memoire-NAV}} == Intro == One way to diagnose memory problems is to measure how much memory is in use. == La Flash == Measuring Flash memory usage is trivial. The... »

2013-08-31T10:10:59Z

Page créée avec « {{Arduino-Memoire-NAV}} == Intro == One way to diagnose memory problems is to measure how much memory is in use. == La Flash == Measuring Flash memory usage is trivial. The... »

Nouvelle page

{{Arduino-Memoire-NAV}}

== Intro ==
One way to diagnose memory problems is to measure how much memory is in use.

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

{{ADFImage|Arduino-Memoire-40.JPG}}

== EEPROM ==
You are 100% in control of EEPROM usage. You have to read and write each byte to a specific address, so there is no excuse for not knowing exactly which bytes are in use!

<nowiki>// ************************************************
// Write floating point values to 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++);
}
}

// ************************************************
// Read floating point values from 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;
}</nowiki>

== SRAM ==
SRAM usage is more dynamic and therefore more difficult to measure. The free_ram() function below is one way to do this. You can add this function definition to your code, then call it from various places in your code to report the amount of free SRAM.

SRAM utilization is dynamic and will change over time. So It is important to call free_ram() at various times and from various places in your sketch to see how it changes over time.

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

What free_ram() is actually reporting is the space between the heap and the stack. it does not report any de-allocated memory that is buried in the heap. Buried heap space is not usable by the stack, and may be fragmented enough that it is not usable for many heap allocations either. The space between the heap and the stack is what you really need to monitor if you are trying to avoid stack crashes.

{{ADFImage|Arduino-Memoire-41.jpg}}

{{Arduino-Memoire-TRAILER}}

@@ Ligne 2 : / Ligne 2 : @@
 == Intro ==
-{{bloc-etroit|text=Une des façon de diagnostiquer les problèmes de mémoire est de mesure la quantité de mémoire utilisée.}}
+{{bloc-etroit|text=Une façon de diagnostiquer les problèmes de mémoire est de mesure la quantité de mémoire utilisée.}}
 == La Flash ==

@@ Ligne 39 : / Ligne 39 : @@
 == SRAM ==
-SRAM usage is more dynamic and therefore more difficult to measure. The free_ram() function below is one way to do this. You can add this function definition to your code, then call it from various places in your code to report the amount of free 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.
-SRAM utilization is dynamic and will change over time. So It is important to call free_ram() at various times and from various places in your sketch to see how it changes over time.
+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.
    <nowiki>int freeRam ()
@@ Ligne 50 : / Ligne 50 : @@
 }</nowiki>
-What free_ram() is actually reporting is the space between the heap and the stack. it does not report any de-allocated memory that is buried in the heap. Buried heap space is not usable by the stack, and may be fragmented enough that it is not usable for many heap allocations either. The space between the heap and the stack is what you really need to monitor if you are trying to avoid stack crashes.
+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''.
 {{ADFImage|Arduino-Memoire-41.jpg|480px}}

@@ Ligne 10 : / Ligne 10 : @@
 == EEPROM ==
-You are 100% in control of EEPROM usage. You have to read and write each byte to a specific address, so there is no excuse for not knowing exactly which bytes are in use!
+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!
   <nowiki>// ************************************************
-// Write floating point values to EEPROM
+// Ecriture d'une valeur en virgule flottant dans EEPROM
 // ************************************************
 void EEPROM_writeDouble(int address, double value)
@@ Ligne 25 : / Ligne 25 : @@
 // ************************************************
-// Read floating point values from EEPROM
+// Lecture d'une valeur en virgule flottant depuis EEPROM
 // ************************************************
 double EEPROM_readDouble(int address)
@@ Ligne 36 : / Ligne 36 : @@
+   }
    return value;
 }</nowiki>
 == SRAM ==

@@ Ligne 52 : / Ligne 52 : @@
 What free_ram() is actually reporting is the space between the heap and the stack. it does not report any de-allocated memory that is buried in the heap. Buried heap space is not usable by the stack, and may be fragmented enough that it is not usable for many heap allocations either. The space between the heap and the stack is what you really need to monitor if you are trying to avoid stack crashes.
-{{ADFImage|Arduino-Memoire-41.jpg}}
+{{ADFImage|Arduino-Memoire-41.jpg|480px}}
 {{Arduino-Memoire-TRAILER}}