Guides · 16 min de lecture

Arduino mémoire insuffisante : corriger Sketch too big et RAM

Arduino en mémoire insuffisante ? Flash, SRAM et EEPROM, F() et PROGMEM, tableaux char au lieu de String, mesure de la RAM libre, passage au Mega ou à l'ESP32.

Le message de mémoire insuffisante sur Arduino signifie que ton programme ou tes variables ne tiennent pas dans la mémoire de la carte, et il apparaît généralement sous deux formes : soit le code ne se téléverse jamais parce que la compilation s'arrête sur Sketch too big, soit il se téléverse après l'avertissement Low memory available, stability problems may occur et la carte redémarre ensuite au hasard, affiche des caractères incohérents dans le moniteur série ou se fige. Comme l'Arduino Uno n'a que 32 Ko de mémoire programme et 2 Ko de RAM, ce problème est très fréquent dans les projets qui combinent un écran, une carte SD et quelques capteurs.

Dans ce guide, tu verras d'abord la différence entre Flash, SRAM et EEPROM et comment lire les deux lignes affichées à la fin d'une compilation. Ensuite, à partir de valeurs mesurées en compilant réellement pour un Uno, tu apprendras quelle ligne consomme combien de mémoire, comment sortir les données constantes de la RAM avec la macro F() et PROGMEM, pourquoi préférer les tableaux char à String, ce que coûtent discrètement les bibliothèques et comment mesurer la RAM libre pendant l'exécution. La dernière partie montre comment surveiller la mémoire sur l'ESP32 et la Raspberry Pi Pico, et quand passer à un Mega ou à un ESP32 est la bonne décision.

Carte Arduino Uno et son microcontrôleur ATmega328P
L'ATmega328P au cœur de l'Arduino Uno : 32 Ko de flash, 2 Ko de SRAM et 1 Ko d'EEPROM. La plupart des problèmes de mémoire se jouent dans ces 2 Ko de RAM.

Les trois mémoires d'un Arduino : Flash, SRAM et EEPROM

Le microcontrôleur d'un Arduino contient trois mémoires aux rôles totalement différents. La Flash (mémoire programme) stocke ton code compilé ; elle ne s'efface pas hors tension et n'est écrite qu'au téléversement. La SRAM (mémoire de travail) accueille les variables, les appels de fonction et les données temporaires ; elle est rapide mais se vide quand la carte s'éteint. L'EEPROM est une petite zone réservée aux données à conserver qui changent peu, comme les réglages et les valeurs d'étalonnage. Sur les cartes AVR comme l'Uno, ces trois mémoires occupent des espaces d'adressage séparés (architecture Harvard). Ce détail explique pourquoi les techniques F() et PROGMEM présentées plus bas sont nécessaires.

MémoireTaille sur l'UnoQue contient-elle ?Hors tensionEndurance en écriture
Flash32 Ko (0,5 Ko pour le bootloader, 32256 octets utilisables)Code du programme, données PROGMEMConservéeEnviron 10 000 cycles d'effacement/écriture
SRAM2 Ko (2048 octets)Variables, tableaux, pile et tasEffacéeIllimitée
EEPROM1 Ko (1024 octets)Réglages, compteurs, étalonnageConservéeEnviron 100 000 écritures par cellule

Utiliser l'EEPROM à la place de la RAM n'est pas une solution : elle est lente et chaque cellule supporte un nombre limité d'écritures. Si tu écris à chaque tour de boucle une variable qui change vite, tu peux user cette cellule en quelques jours. Les bonnes façons d'utiliser l'EEPROM sont détaillées dans l'article utiliser l'EEPROM de l'Arduino.

Quantité de mémoire selon la carte

CarteFlash (programme)SRAMEEPROM
Arduino Uno R3 / Nano (ATmega328P)32 Ko (Uno 32256, Nano 30720 octets utilisables)2 Ko1 Ko
Arduino Leonardo / Pro Micro (ATmega32U4)32 Ko (28672 octets utilisables)2,5 Ko1 Ko
Arduino Mega 2560256 Ko (253952 octets utilisables)8 Ko4 Ko
Arduino Uno R4 (RA4M1)256 Ko32 Ko8 Ko (flash de données)
ESP32 (WROOM)Puce flash de 4 Mo (partition d'application par défaut 1,25 Mo)520 Ko (environ 300 Ko de tas restent au programme)Aucune ; Preferences stocke en flash
Raspberry Pi Pico (RP2040)Puce flash de 2 Mo264 KoAucune ; émulée en flash

L'écart est énorme : l'ESP32 a 260 fois la RAM de l'Uno et la Pico environ 130 fois. C'est pourquoi les économies de mémoire qui demandent beaucoup d'efforts sur un Uno sont souvent inutiles sur un ESP32. Pourtant, l'Uno, le Nano et le Pro Mini restent les cartes les plus utilisées grâce à leur prix et à leur simplicité ; apprendre à vivre avec 2 Ko sert donc à tout utilisateur d'Arduino.

Lire la sortie de compilation : Sketch uses et Global variables use

À la fin de chaque compilation réussie, l'Arduino IDE affiche deux lignes. Compile pour l'Uno un croquis avec setup() et loop() vides et tu verras Sketch uses 444 bytes (1%) of program storage space et Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. La première ligne indique la place du programme en flash, la seconde la RAM occupée par les variables globales et statiques. Point essentiel : la seconde ligne ne compte que les variables dont la taille est connue à la compilation. Les variables locales des fonctions (la pile) et la mémoire allouée à l'exécution avec String ou malloc (le tas) n'y sont pas incluses. L'espace restant « local variables » est ce qu'elles doivent se partager.

MessageQuand apparaît-il ?Que signifie-t-il ?
Sketch uses ... bytes (x%) of program storage spaceÀ chaque compilationPlace occupée par le code en flash
Global variables use ... bytes (x%) of dynamic memoryÀ chaque compilationPart de RAM des variables globales et statiques
Low memory available, stability problems may occur.Quand les variables globales dépassent environ 75 % de la RAMLe code se téléverse mais il reste peu de place pour la pile et le tas
Sketch too big et text section exceeds available space in boardQuand le programme ne tient pas en flashTéléversement impossible ; il faut réduire la flash utilisée
Not enough memory et data section exceeds available space in boardQuand les variables globales dépassent la RAMTéléversement impossible ; il faut réduire la RAM utilisée
L'avertissement « Low memory » n'est pas une erreur et le code se téléverse sans broncher ; c'est justement là le danger. Un croquis avec int veri[700];, par exemple, utilise 1588 octets (77 %) de variables globales sur l'Uno et ne laisse que 460 octets à la pile et au tas. Quand quelques appels de fonction imbriqués, une concaténation de String ou un tampon alloué par une bibliothèque dans begin() épuisent cet espace, le programme plante. Les symptômes sont des redémarrages aléatoires, des variables corrompues et des blocages ; pour les distinguer des problèmes d'alimentation, lis aussi l'Arduino redémarre tout seul.

Dans la SRAM : variables globales, tas et pile

Les 2048 octets de RAM de l'Uno sont divisés en quatre zones. Tout en bas se trouvent les variables globales initialisées (.data), au-dessus celles qui démarrent à zéro (.bss) ; le compilateur affiche la somme des deux dans la ligne « Global variables use ». Vient ensuite le tas (heap), qui grandit vers le haut : les objets String et la mémoire allouée avec new et malloc s'y trouvent. Depuis le sommet de la RAM, la pile (stack) grandit vers le bas : chaque appel de fonction y dépose son adresse de retour et ses variables locales, et les registres y sont sauvegardés lors d'une interruption. Si le tas et la pile se rejoignent dans l'espace libre entre eux, ils s'écrasent mutuellement et le programme devient imprévisible.

ZoneContenuSens de croissanceVisible dans la sortie de compilation ?
.dataVariables globales et statiques initialisées, textes sans F()FixeOui
.bssVariables globales et statiques non initialisées (zéro), tampons des bibliothèquesFixeOui
Tas (heap)String, new, malloc, tampons alloués par certaines bibliothèques dans begin()Vers le hautNon
Pile (stack)Variables locales, adresses de retour, registres sauvegardés lors des interruptionsVers le basNon

Cette organisation a deux conséquences importantes. D'abord, tout texte non placé dans F() est copié dans .data, car le processeur AVR ne peut pas lire des données en flash comme une variable ordinaire. Ensuite, le tas se fragmente : en créant et supprimant des String de tailles différentes, de petits trous apparaissent et, même si la mémoire libre totale semble suffisante, un gros bloc ne peut plus être alloué. Voilà pourquoi, pour un programme qui tourne longtemps sur un Uno, le plus sûr est de toucher le moins possible au tas.

Mesure d'abord : combien de mémoire coûte chaque ligne ?

La première étape pour résoudre un problème de mémoire est de mesurer, pas de deviner. Chaque ligne du tableau ci-dessous est la sortie réelle d'un petit croquis compilé séparément pour l'Arduino Uno avec le cœur Arduino AVR 1.8.6. Les valeurs peuvent varier de quelques octets selon les versions des bibliothèques et du cœur, mais les proportions restent toujours les mêmes.

Contenu du croquisFlash (octets)RAM globale (octets)
setup() et loop() vides4449
Serial.begin(9600)1438184
+ Serial.println("un texte de 44 caractères")1518232
Le même texte avec F()1530188
analogRead + Serial.println(int)1892188
Calcul en float + Serial.println(float)3380200
Concaténation String : "A0=" + String(analogRead(A0))3316202
La même chose avec snprintf et un tableau char3232194
Une seule écriture avec Wire (I2C)2476225
Carte SD : begin, open, println, close10496837
Tableau int veri[700]17801588 (77 %, avertissement Low memory)
Tableau int veri[950]17802088 (101 %, ne compile pas)

Les leçons sont claires. Serial.begin() à lui seul demande 175 octets de RAM, car le port série réserve un tampon de réception de 64 octets et un tampon d'émission de 64 octets. Un seul texte de 44 caractères coûte 44 octets de RAM ; écrit avec F(), cette RAM revient. Utiliser float ajoute environ 1,5 Ko de code à virgule flottante en flash. La bibliothèque SD consomme à elle seule 10 Ko de flash et environ 830 octets de RAM : 40 % de la RAM de l'Uno partent dans un simple fichier journal. La RAM globale de l'exemple String paraît faible, mais son vrai coût apparaît dans le tas pendant l'exécution et ne se voit jamais dans la sortie de compilation.

La macro F() : sortir les textes constants de la RAM

Sur l'Uno, chaque texte entre guillemets comme "Temperature : " se trouve en flash, mais il est copié en RAM au démarrage du programme et y occupe de la place pour toujours. La macro F() empêche cette copie : le texte reste en flash et des fonctions comme Serial.print le lisent caractère par caractère directement en flash. F() fonctionne avec tout objet dérivé de la classe Print, dont Serial, LiquidCrystal, LiquidCrystal_I2C, Adafruit SSD1306 et les fichiers SD. Dans un projet avec menus, messages d'erreur et textes d'aide, ajouter simplement F() peut libérer quelques centaines d'octets de RAM. Le code ci-dessous montre la différence et mesure la RAM libre pendant l'exécution :

C++ (Arduino IDE)
1// Boş RAM'i ölçmek ve F() ile RAM kazanmak (Uno, Nano, Mega)
2// Measure free RAM and save RAM with F() (Uno, Nano, Mega)
3extern int __heap_start, *__brkval;   // avr-libc heap sınırları / avr-libc heap limits
4
5int bosRam() {
6  int yerel;                          // stack'in o anki tepesi / current top of the stack
7  return (int)&yerel - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
8}
9
10void setup() {
11  Serial.begin(9600);
12  Serial.println("Bu metin RAM'e kopyalanir");   // RAM'de 26 bayt / 26 bytes of RAM
13  Serial.println(F("Bu metin flasta kalir"));     // RAM'de 0 bayt / 0 bytes of RAM
14  Serial.print(F("Bos RAM / Free RAM: "));
15  Serial.println(bosRam());
16}
17
18void loop() {
19}

La fonction bosRam() calcule la distance entre le sommet actuel de la pile et la fin du tas, autrement dit combien d'octets il reste avant qu'ils se rencontrent. Appelle-la dans loop() juste après une mise à jour de l'écran ou une écriture sur la SD pour saisir le pire moment. Règle pratique : sur l'Uno, ne laisse pas la RAM libre descendre sous 200–300 octets pendant l'exécution. F() ne fonctionne pas avec les fonctions qui attendent un char* (strcmp, strcpy) ; pour elles, tu utilises les versions _P et la macro PSTR() présentées plus bas.

PROGMEM : garder les grandes tables en flash

F() ne sert qu'aux textes. Pour les grands tableaux qui ne changent jamais, comme des suites de notes, des icônes d'écran (bitmaps), des tables de caractères, des courbes d'étalonnage ou des listes de messages, on utilise le mot-clé PROGMEM. Un tableau déclaré avec PROGMEM n'est jamais copié en RAM ; pour le lire, il faut des fonctions spéciales comme pgm_read_byte et pgm_read_word au lieu de l'accès normal. Une mélodie de 100 notes avec ses tables de fréquences et de durées occupe par exemple 400 octets ; c'est un cinquième de la RAM de l'Uno, et PROGMEM la déplace entièrement en flash.

C++ (Arduino IDE)
1// Mesaj listesi ve nota tablosu flaşta (PROGMEM)
2// Message list and note table kept in flash (PROGMEM)
3const char m0[] PROGMEM = "Sistem hazir";
4const char m1[] PROGMEM = "Sensor hatasi";
5const char m2[] PROGMEM = "Kapi acik";
6const char* const mesajlar[] PROGMEM = { m0, m1, m2 };   // işaretçi tablosu da flaşta / pointer table in flash too
7
8const uint16_t notalar[] PROGMEM = { 262, 294, 330, 349, 392, 440, 494, 523 };   // Do-Re-Mi ... Do (Hz)
9const byte BUZZER_PIN = 8;
10
11void setup() {
12  Serial.begin(9600);
13  char tampon[20];                                     // RAM'de tek ortak tampon / one shared RAM buffer
14  for (byte i = 0; i < 3; i++) {
15    strcpy_P(tampon, (const char*)pgm_read_ptr(&mesajlar[i]));   // flaştan RAM'e kopyala / copy flash -> RAM
16    Serial.println(tampon);
17  }
18  for (byte i = 0; i < 8; i++) {
19    uint16_t frekans = pgm_read_word(&notalar[i]);     // 2 baytlık değeri oku / read a 2-byte value
20    tone(BUZZER_PIN, frekans, 200);
21    delay(250);
22  }
23}
24
25void loop() {
26}
Fonction / macroQue fait-elle ?
pgm_read_byte(&tableau[i])Lit 1 octet en flash (tableaux byte, char, uint8_t, bitmaps)
pgm_read_word(&tableau[i])Lit 2 octets en flash (int, uint16_t ; tables de notes et de nombres sur l'Uno)
pgm_read_dword / pgm_read_floatLit des valeurs long et float sur 4 octets
pgm_read_ptr(&table[i])Lit un pointeur stocké en flash (tables de textes)
strcpy_P(dest, source)Copie un texte de la flash vers un tampon en RAM
strcmp_P(texte_ram, PSTR("..."))Compare un texte en RAM avec un texte en flash
strlen_P / memcpy_PDonne la longueur d'un texte en flash, copie un bloc depuis la flash
Sur l'ESP32 et la Pico, les tableaux déclarés const restent déjà en flash ; PROGMEM n'y a aucun effet mais ne provoque pas d'erreur, et les fonctions pgm_read_* sont définies. Un code écrit avec PROGMEM compile donc sur les trois cartes. Une exception : pour lire une table de pointeurs, pgm_read_word fonctionne sur l'Uno mais tronque le pointeur sur les cartes 32 bits ; pour un code portable, utilise pgm_read_ptr.

Utiliser des tableaux char plutôt que String

La classe String d'Arduino est pratique, mais à chaque concaténation (+) elle demande un nouveau bloc au tas et libère l'ancien. Répété des milliers de fois dans le minuscule tas de l'Uno, cela crible la mémoire de trous. Le programme tourne bien pendant des heures puis se fige soudain, et le bug est très difficile à trouver. La solution, ce sont les tableaux char de taille connue d'avance : la mémoire est réservée une fois, ne se fragmente jamais et les octets utilisés apparaissent dans la sortie de compilation. Le code suivant lit les commandes du moniteur série sans String et met la mesure en forme sur une seule ligne :

C++ (Arduino IDE)
1// String yerine sabit boyutlu char dizileri / fixed-size char arrays instead of String
2char komut[16];          // gelen komut tamponu / incoming command buffer
3byte konum = 0;          // tampondaki karakter sayısı / characters in the buffer
4
5void setup() {
6  Serial.begin(9600);
7  pinMode(13, OUTPUT);
8  Serial.println(F("Komutlar / Commands: LED ON, LED OFF, OLC"));
9}
10
11void olcumGonder() {
12  int ham = analogRead(A0);
13  float volt = ham * 5.0 / 1023.0;          // Uno: 5 V, 10 bit
14  char vMetin[8];
15  dtostrf(volt, 4, 2, vMetin);              // AVR'de snprintf %f desteklemez / AVR snprintf has no %f
16  char satir[40];
17  snprintf(satir, sizeof(satir), "A0=%d ham, %s V", ham, vMetin);   // taşma olmaz / never overflows
18  Serial.println(satir);
19}
20
21void komutIsle(const char* k) {
22  if (strcmp_P(k, PSTR("LED ON")) == 0) digitalWrite(13, HIGH);     // PSTR: metin flaşta / literal in flash
23  else if (strcmp_P(k, PSTR("LED OFF")) == 0) digitalWrite(13, LOW);
24  else if (strcmp_P(k, PSTR("OLC")) == 0) olcumGonder();
25  else Serial.println(F("Bilinmeyen komut / Unknown command"));
26}
27
28void loop() {
29  while (Serial.available()) {
30    char c = Serial.read();
31    if (c == '\n') {                        // satır bitti / line complete
32      komut[konum] = '\0';
33      komutIsle(komut);
34      konum = 0;
35    } else if (c != '\r' && konum < sizeof(komut) - 1) {
36      komut[konum++] = c;                   // taşmadan ekle / append without overflow
37    }
38  }
39}

Trois détails du code méritent l'attention. snprintf connaît la taille du tampon et ne déborde donc jamais du tableau, même si le texte est long ; sprintf n'offre pas cette protection. Comme la famille printf de l'AVR ne prend pas en charge le format %f par défaut, la valeur float est d'abord convertie en texte avec dtostrf. Enfin, la limite du tampon de commande (konum < sizeof(komut) - 1) empêche une longue ligne d'écraser une autre partie de la mémoire. Si tu dois utiliser String (certaines bibliothèques en renvoient), réserve au moins la place dès setup() avec texte.reserve(64) et déclare le String en global ; la fragmentation diminue alors fortement.

Le bon type de données et les variables locales

TypeUno (AVR)ESP32 / PicoPlage de valeurs (Uno)
bool, char, byte1 octet1 octetbyte : 0–255
int2 octets4 octets-32768 à 32767
unsigned int, uint16_t2 octetsuint16_t 2, unsigned int 4 octets0–65535
long, unsigned long4 octets4 octetsunsigned long : 0–4 294 967 295
float4 octets4 octetsEnviron 6–7 chiffres significatifs
double4 octets (comme float)8 octetsAucune différence avec float sur l'Uno
  • byte pour les petits nombres : utiliser byte au lieu de int pour les numéros de broche, les compteurs et les pourcentages entre 0 et 255 économise 1 octet par variable et 200 octets dans un tableau de 200 éléments.
  • const pour les broches : le compilateur intègre directement dans le code les constantes déclarées comme const byte LED_PIN = 13; et ne leur réserve pas de RAM.
  • États marche/arrêt dans des bits : huit variables bool occupent 8 octets ; si tu stockes la même information dans les bits d'un octet avec bitRead et bitWrite, 1 octet suffit.
  • Attention aux grands tableaux locaux : un char tampon[300]; déclaré dans une fonction n'apparaît pas dans la sortie de compilation, mais il prend 300 octets de pile à chaque appel. Rends les gros tampons globaux pour que leur taille soit visible.
  • Évite la récursivité : chaque fonction qui s'appelle elle-même ouvre un nouveau niveau sur la pile ; sur l'Uno, quelques dizaines de niveaux suffisent à épuiser la RAM.
  • Passe les grosses structures par référence : passer un struct par valeur en place une copie sur la pile ; le passer par référence comme const Reglages& r évite la copie.

Le coût caché des bibliothèques

Quand un projet manque soudain de mémoire, le coupable n'est souvent pas ton code mais une bibliothèque ajoutée. Certaines réservent la RAM à la compilation (tampon global), d'autres la prennent dans le tas lors de l'appel à begin() ; dans ce second cas, la sortie de compilation paraît innocente mais la mémoire s'épuise une fois la carte en marche. Une partie des valeurs ci-dessous vient du tableau de mesures précédent, l'autre des tailles de tampon des bibliothèques :

Bibliothèque / fonctionCoût en RAM (Uno)Quand est-elle allouée ?Option plus légère
SerialEnviron 175 octets (tampons de 64 + 64 octets)À la compilation (global)Supprimer Serial s'il n'est pas utile
Wire (I2C)Environ 215 octetsÀ la compilation (global)Inévitable même avec un seul périphérique I2C ; économise ailleurs
SoftwareSerialEnviron 120 octets (tampon de réception de 64 octets)À la compilation (global)Le port série matériel si possible, ou les ports supplémentaires du Mega
SDEnviron 830 octets, plus environ 10 Ko de flashÀ la compilation (global)Confier l'enregistrement à un ESP32 ou à un Mega
Adafruit SSD1306 128x64Tampon d'image de 1024 octetsDans le tas, lors de begin()U8g2 en mode page (128 octets) ou U8x8 pour du texte seul
Adafruit NeoPixel / FastLED3 octets par LED (60 LED = 180 octets)Au démarrageLimiter le nombre de LED à la longueur réelle du ruban

Ce tableau explique pourquoi utiliser en même temps un écran OLED, une carte SD et un module Wi-Fi sur un Uno est presque impossible : le tampon du SSD1306 et la bibliothèque SD totalisent déjà 1,8 Ko et ne laissent presque rien des 2 Ko de RAM à ton programme. L'erreur SSD1306 allocation failed des écrans OLED correspond exactement à l'échec de cette allocation dans le tas ; tu trouveras aussi des solutions dans l'article écran OLED SSD1306.

Sketch too big : réduire l'occupation de la flash

  • Coupe les sorties de débogage : les lignes Serial.print ajoutées pendant le développement coûtent flash et RAM. Avec la macro DEBUG ci-dessous, tu les retires toutes de la compilation en modifiant une seule ligne.
  • Évite float et sprintf : comme le montrent les mesures, float ajoute environ 1,5 Ko et snprintf plus de 1 Ko de code. Multiplier la température par 10 et la stocker en int (235 au lieu de 23,5 °C) suffit dans la plupart des projets.
  • Transforme le code répété en fonctions et en tableaux : garder les numéros de broche dans un tableau et les traiter dans une boucle, plutôt que d'écrire un bloc de dix lignes par LED, raccourcit nettement le code.
  • Choisis une bibliothèque plus petite : sans graphisme, U8x8 ou LiquidCrystal_I2C prennent bien moins de place que les bibliothèques basées sur Adafruit GFX. Plutôt que d'ajouter toute une bibliothèque pour une seule fonction, envisage d'écrire cette partie toi-même.
  • Vérifie la carte sélectionnée : l'Arduino IDE calcule la limite selon la carte choisie : 32256 octets pour l'Uno, 30720 pour le Nano (ancien ou nouveau bootloader) et 28672 pour le Leonardo. Avec la mauvaise carte, la limite comme les définitions de broches sont fausses.
  • Passe à une carte plus grande : si cela ne tient toujours pas, un Mega (256 Ko) ou un ESP32 (1,25 Mo et plus) exécutent le même code avec de petites modifications.
C++ (Arduino IDE)
1// DEBUG makrosu: hata ayıklama çıktısını tek satırla aç/kapat
2// DEBUG macro: switch debug output on/off with one line
3#define DEBUG 1          // yayında 0 yap / set to 0 for release
4
5#if DEBUG
6  #define DBG(x)   Serial.print(x)
7  #define DBGLN(x) Serial.println(x)
8#else
9  #define DBG(x)
10  #define DBGLN(x)
11#endif
12
13void setup() {
14#if DEBUG
15  Serial.begin(9600);
16#endif
17  pinMode(13, OUTPUT);
18  DBGLN(F("Basladi / Started"));
19}
20
21void loop() {
22  int deger = analogRead(A0);
23  digitalWrite(13, deger > 512 ? HIGH : LOW);   // asıl iş / the real job
24  DBG(F("A0: "));
25  DBGLN(deger);
26  delay(500);
27}

Avec DEBUG 1, ce croquis utilise 2292 octets de flash et 188 octets de RAM sur l'Uno ; avec DEBUG 0, le code Serial disparaît complètement de la compilation et les valeurs tombent à 934 octets de flash et 9 octets de RAM. Les 1,3 Ko de flash et 179 octets de RAM d'écart suffisent souvent pour ajouter une nouvelle fonction à un projet terminé.

Mesurer la mémoire sur l'ESP32

L'ESP32 a beaucoup de mémoire, mais pas une mémoire illimitée. Activer le Wi-Fi réserve des dizaines de Ko de RAM, et avec le Bluetooth en plus on peut approcher les 100 Ko ; serveurs web, documents JSON et tampons d'image remplissent aussi vite la mémoire. Certains modules comme l'ESP32-CAM disposent de PSRAM supplémentaire (généralement 4 Mo) pour les gros tampons. Côté flash, si ton application ne tient pas dans la partition par défaut de 1,25 Mo, l'option « Huge APP » du réglage Partition Scheme dans le menu Outils permet de monter à 3 Mo. Pour les caractéristiques générales de l'ESP32, vois Qu'est-ce que l'ESP32 ?.

C++ (Arduino IDE)
1// ESP32 bellek raporu / ESP32 memory report
2void setup() {
3  Serial.begin(115200);
4  delay(500);
5  Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
6  Serial.printf("En dusuk heap / Minimum free heap: %u bayt\n", ESP.getMinFreeHeap());
7  Serial.printf("En buyuk blok / Largest free block: %u bayt\n", ESP.getMaxAllocHeap());
8  Serial.printf("PSRAM: %u bayt\n", ESP.getPsramSize());
9  Serial.printf("Program / Sketch: %u, bos alan / free: %u bayt\n", ESP.getSketchSize(), ESP.getFreeSketchSpace());
10}
11
12void loop() {
13  // loop görevinin hiç kullanılmamış stack'i / never-used stack of the loop task
14  Serial.printf("loop stack bos / free: %u bayt\n", (unsigned)uxTaskGetStackHighWaterMark(NULL));
15  Serial.printf("Bos heap / Free heap: %u bayt\n", ESP.getFreeHeap());
16  delay(5000);
17}

Les deux valeurs les plus utiles ici sont getMinFreeHeap et getMaxAllocHeap. La première donne le tas libre le plus bas depuis le démarrage, la seconde le plus gros bloc allouable d'un seul tenant. Si le tas libre affiche 100 Ko mais que le plus gros bloc est sous 10 Ko, le tas est fragmenté et un gros String ou document JSON risque de ne pas pouvoir être alloué. Sur l'ESP32, loop() tourne dans sa propre tâche avec une pile de 8 Ko ; uxTaskGetStackHighWaterMark indique la partie de cette pile jamais utilisée, et si elle descend sous quelques centaines d'octets, tu peux rencontrer l'erreur « Stack canary watchpoint triggered ».

La mémoire sur la Raspberry Pi Pico et en MicroPython

Les 264 Ko de RAM de la Pico sont énormes comparés à l'Uno, mais l'interpréteur MicroPython en utilise une partie ; il reste généralement environ 190 Ko de tas à ton programme. En MicroPython, la mémoire est gérée par un ramasse-miettes (garbage collector) : les objets qui ne servent plus sont nettoyés quand gc.collect() est appelé ou quand la mémoire va manquer. Quand elle est vraiment épuisée, tu obtiens MemoryError: memory allocation failed. Concaténer des textes dans une boucle, créer de grandes listes et un seul fichier de code très long en sont les causes les plus fréquentes.

Python
1import gc
2import micropython
3
4gc.collect()                                   # önce çöpleri topla / collect garbage first
5print("Bos RAM / Free RAM:", gc.mem_free(), "bayt")
6print("Kullanilan / Used:", gc.mem_alloc(), "bayt")
7micropython.mem_info()                         # ayrıntılı rapor / detailed report
8
9# Kötü: her turda yeni metin nesnesi / bad: a new string object every loop
10# satir = ""
11# for i in range(100): satir += str(i) + ","
12
13# İyi: tek seferlik bytearray tamponu / good: one preallocated bytearray buffer
14tampon = bytearray(64)
15for i in range(10):
16    tampon[i] = 48 + i                         # ASCII '0'..'9'
17print(bytes(tampon[:10]))

Pour préserver la mémoire en MicroPython, alloue les tampons à l'avance avec bytearray et réutilise-les dans la boucle, définis les nombres constants avec const(), transforme les gros modules en fichiers .mpy précompilés avec mpy-cross et appelle gc.collect() avant les tâches longues. Tu trouveras les commandes de base de MicroPython sur la Pico dans les bases de MicroPython, et les caractéristiques générales de la carte dans Qu'est-ce que la Raspberry Pi Pico ?.

Quand passer à un Mega ou à un ESP32 ?

Carte Arduino Mega 2560
Arduino Mega 2560 : 256 Ko de flash, 8 Ko de SRAM et 4 Ko d'EEPROM. Le code de l'Uno y tourne souvent sans aucune modification.
SituationRecommandation
Après F(), PROGMEM et les tableaux char, il reste plus de 300 octets de RAM libreReste sur l'Uno ; problème réglé
Plusieurs capteurs et un menu avec OLED ou SD, et la RAM ne suffit toujours pasArduino Mega 2560 : 4 fois plus de RAM, mêmes broches 5 V et bibliothèques
Le programme dépasse 32 Ko mais la RAM suffitMega ou Uno R4 : 256 Ko de flash
Il te faut du Wi-Fi, un serveur web, de gros tampons ou du traitement d'imageESP32 : 520 Ko de RAM, 4 Mo de flash, Wi-Fi et Bluetooth
Tu veux travailler en MicroPythonRaspberry Pi Pico ou Pico W
Un petit nœud capteur qui doit tenir des mois sur pilesOptimise sur l'Uno ou utilise un Pro Mini ; une grande carte consomme plus

En passant au Mega, l'essentiel de ton code reste identique ; rappelle-toi seulement que l'I2C se trouve sur les broches 20 (SDA) et 21 (SCL) et le SPI sur les broches 50–53. Le passage à l'ESP32 implique des différences comme le niveau logique de 3,3 V, d'autres numéros de broche et le résultat sur 12 bits (0–4095) d'analogRead. Pour choisir la carte qui te convient, lis le comparatif Arduino ou ESP32, et pour une option compatible 5 V avec bien plus de mémoire, l'article Arduino Uno R4.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Sketch too big, le code ne se téléverse pasLe programme ne tient pas en flashCoupe le débogage, réduis float et sprintf, prends des bibliothèques plus petites, au besoin un Mega
Le code se téléverse mais se fige après quelques minutesLes concaténations de String fragmentent le tasTableaux char et snprintf au lieu de String ; mesure la RAM libre
Caractères incohérents dans le moniteur série, variables qui changent seulesLa pile écrase le tasRamène la RAM globale sous 75 %, supprime les grands tableaux locaux
SSD1306 allocation failedbegin() n'arrive pas à allouer le tampon de 1 KoMets les textes dans F(), passe à U8g2 en mode page
La carte redémarre au hasard alors que la mémoire semble correcteProblème d'alimentation plutôt que de mémoireAlimente moteurs et relais à part, ajoute un condensateur
Les éléments d'un tableau affichent des valeurs absurdesÉcriture au-delà des limites du tableauVérifie l'indice ; calcule les limites de boucle avec sizeof
Stack canary watchpoint triggered sur l'ESP32La pile d'une tâche a débordéRends globaux les grands tableaux locaux ou agrandis la pile de la tâche
Pour éviter les problèmes de mémoire dès le départ, note les deux pourcentages de la sortie de compilation chaque fois que tu ajoutes un module au projet. Commence à appliquer F() et PROGMEM dès que la RAM globale dépasse 60 % ; attendre l'avertissement des 75 %, c'est repousser le problème au moment où il est le plus dur à résoudre.

Un manque de mémoire sur Arduino se règle le plus souvent sans changer de carte : déplacer les textes constants en flash avec F(), mettre les grandes tables en PROGMEM, utiliser des tableaux char au lieu de String et retirer les bibliothèques inutiles redonnent une marge étonnante aux 2 Ko de RAM. Dans l'application BlueGrays, tu peux explorer des projets gourmands en mémoire comme des jeux sur OLED, des mélodies au buzzer et des animations sur matrice LED, avec des schémas pas à pas et un code écrit selon ces techniques.

Questions fréquentes

Que signifie Low memory available sur Arduino ?

Cela signifie que les variables globales occupent environ 75 % de la RAM et qu'il reste peu de place pour la pile et le tas. Le code se téléverse, mais des redémarrages aléatoires, des blocages et des variables corrompues peuvent apparaître à l'exécution. Mettre les textes constants dans F() et déplacer les grands tableaux en PROGMEM fait généralement disparaître l'avertissement.

Comment corriger l'erreur Sketch too big ?

Cette erreur indique que le programme ne tient pas dans la mémoire flash. Coupe les sorties Serial de débogage, réduis float et sprintf, regroupe le code répété dans des fonctions et choisis des bibliothèques plus petites. Si cela ne suffit pas, passe à une carte avec plus de flash comme l'Arduino Mega ou un ESP32.

Combien de mémoire a l'Arduino Uno ?

L'ATmega328P de l'Arduino Uno possède 32 Ko de flash (dont 0,5 Ko pour le bootloader), 2 Ko de SRAM et 1 Ko d'EEPROM. Le programme va en flash, les variables en SRAM et les réglages permanents en EEPROM. La plupart des problèmes surviennent dans ces 2 Ko de SRAM.

À quoi sert la macro F() ?

F() empêche que les textes constants passés à des fonctions comme Serial.print soient copiés en RAM et les garde en flash. Sur l'Uno, chaque caractère économise un octet de RAM, ce qui représente des centaines d'octets dans les projets riches en messages. Elle compile aussi sur l'ESP32 et la Pico, mais n'y a aucun effet.

Comment mesurer la RAM libre sur Arduino ?

Sur l'Uno, le Nano et le Mega, on utilise une petite fonction qui calcule la distance entre la pile et le tas grâce aux variables __heap_start et __brkval. Sur l'ESP32, ESP.getFreeHeap() et ESP.getMinFreeHeap() donnent la même information, et en MicroPython gc.mem_free(). Il est important de mesurer au moment où la mémoire est la plus sollicitée.

Pourquoi String pose-t-il problème sur Arduino ?

Les objets String demandent de la mémoire neuve au tas à chaque concaténation et libèrent l'ancienne, si bien que le petit tas de l'Uno se fragmente avec le temps. Même si la mémoire libre totale semble suffisante, un nouveau bloc ne peut plus être alloué et le programme se fige. Les tableaux char de taille fixe et snprintf suppriment complètement ce problème.

Voir tous les projets
Hymne national turc avec un buzzer
AR-15Intermédiaire

Hymne national turc avec un buzzer

Appuie sur le bouton et un petit buzzer se met à jouer l'hymne national turc, note après note.

4.8(114)
235
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Jeu de Raquettes - SSD1306
AR-86Intermédiaire
Premium

Jeu de Raquettes - SSD1306

Une balle, deux raquettes et toi : tu joues au tennis de table, l'un des tout premiers jeux vidéo, sur un petit écran OLED.

4.5(47)
65
OLED T-Rex Run : Jeu de dinosaures Arduino
AR-87Avancé
Premium

OLED T-Rex Run : Jeu de dinosaures Arduino

Le jeu du dinosaure qui apparaît quand internet est coupé, maintenant sur ton bureau : le dinosaure court sur le petit écran OLED, les cactus foncent sur lui et tu sautes avec un seul bouton.

4.7(33)
53
Serpent à pixels Matrice 8x8
AR-88Avancé
Premium

Serpent à pixels Matrice 8x8

Construis de tes mains le jeu classique du serpent et joue. Sur une matrice lumineuse colorée de 8x8, tu guides un serpent vert avec un joystick et tu manges des pommes rouges ; à chaque pomme, le…

4.7(39)
57
Jeu de mémoire avec Arduino (4 LED + 4 boutons + buzzer)
AR-93Avancé
Premium

Jeu de mémoire avec Arduino (4 LED + 4 boutons + buzzer)

Tu as confiance en ta mémoire ? Quatre LED de couleur s'allument dans un certain ordre, chacune avec sa propre note, et tu dois refaire la même suite en appuyant sur les boutons.

4.8(46)
69
Serrure à code avec clavier 4x4 et écran LCD
AR-64Avancé
Premium

Serrure à code avec clavier 4x4 et écran LCD

Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.

4.8(59)
75