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.

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émoire | Taille sur l'Uno | Que contient-elle ? | Hors tension | Endurance en écriture |
|---|---|---|---|---|
| Flash | 32 Ko (0,5 Ko pour le bootloader, 32256 octets utilisables) | Code du programme, données PROGMEM | Conservée | Environ 10 000 cycles d'effacement/écriture |
| SRAM | 2 Ko (2048 octets) | Variables, tableaux, pile et tas | Effacée | Illimitée |
| EEPROM | 1 Ko (1024 octets) | Réglages, compteurs, étalonnage | Conservée | Environ 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
| Carte | Flash (programme) | SRAM | EEPROM |
|---|---|---|---|
| Arduino Uno R3 / Nano (ATmega328P) | 32 Ko (Uno 32256, Nano 30720 octets utilisables) | 2 Ko | 1 Ko |
| Arduino Leonardo / Pro Micro (ATmega32U4) | 32 Ko (28672 octets utilisables) | 2,5 Ko | 1 Ko |
| Arduino Mega 2560 | 256 Ko (253952 octets utilisables) | 8 Ko | 4 Ko |
| Arduino Uno R4 (RA4M1) | 256 Ko | 32 Ko | 8 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 Mo | 264 Ko | Aucune ; é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.
| Message | Quand apparaît-il ? | Que signifie-t-il ? |
|---|---|---|
| Sketch uses ... bytes (x%) of program storage space | À chaque compilation | Place occupée par le code en flash |
| Global variables use ... bytes (x%) of dynamic memory | À chaque compilation | Part de RAM des variables globales et statiques |
| Low memory available, stability problems may occur. | Quand les variables globales dépassent environ 75 % de la RAM | Le 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 board | Quand le programme ne tient pas en flash | Téléversement impossible ; il faut réduire la flash utilisée |
| Not enough memory et data section exceeds available space in board | Quand les variables globales dépassent la RAM | Téléversement impossible ; il faut réduire la RAM utilisée |
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.
| Zone | Contenu | Sens de croissance | Visible dans la sortie de compilation ? |
|---|---|---|---|
| .data | Variables globales et statiques initialisées, textes sans F() | Fixe | Oui |
| .bss | Variables globales et statiques non initialisées (zéro), tampons des bibliothèques | Fixe | Oui |
| Tas (heap) | String, new, malloc, tampons alloués par certaines bibliothèques dans begin() | Vers le haut | Non |
| Pile (stack) | Variables locales, adresses de retour, registres sauvegardés lors des interruptions | Vers le bas | Non |
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 croquis | Flash (octets) | RAM globale (octets) |
|---|---|---|
| setup() et loop() vides | 444 | 9 |
| Serial.begin(9600) | 1438 | 184 |
| + Serial.println("un texte de 44 caractères") | 1518 | 232 |
| Le même texte avec F() | 1530 | 188 |
| analogRead + Serial.println(int) | 1892 | 188 |
| Calcul en float + Serial.println(float) | 3380 | 200 |
| Concaténation String : "A0=" + String(analogRead(A0)) | 3316 | 202 |
| La même chose avec snprintf et un tableau char | 3232 | 194 |
| Une seule écriture avec Wire (I2C) | 2476 | 225 |
| Carte SD : begin, open, println, close | 10496 | 837 |
| Tableau int veri[700] | 1780 | 1588 (77 %, avertissement Low memory) |
| Tableau int veri[950] | 1780 | 2088 (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 :
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.
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(¬alar[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 / macro | Que 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_float | Lit 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_P | Donne la longueur d'un texte en flash, copie un bloc depuis la flash |
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 :
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
| Type | Uno (AVR) | ESP32 / Pico | Plage de valeurs (Uno) |
|---|---|---|---|
| bool, char, byte | 1 octet | 1 octet | byte : 0–255 |
| int | 2 octets | 4 octets | -32768 à 32767 |
| unsigned int, uint16_t | 2 octets | uint16_t 2, unsigned int 4 octets | 0–65535 |
| long, unsigned long | 4 octets | 4 octets | unsigned long : 0–4 294 967 295 |
| float | 4 octets | 4 octets | Environ 6–7 chiffres significatifs |
| double | 4 octets (comme float) | 8 octets | Aucune 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 / fonction | Coût en RAM (Uno) | Quand est-elle allouée ? | Option plus légère |
|---|---|---|---|
| Serial | Environ 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 |
| SoftwareSerial | Environ 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 |
| SD | Environ 830 octets, plus environ 10 Ko de flash | À la compilation (global) | Confier l'enregistrement à un ESP32 ou à un Mega |
| Adafruit SSD1306 128x64 | Tampon d'image de 1024 octets | Dans le tas, lors de begin() | U8g2 en mode page (128 octets) ou U8x8 pour du texte seul |
| Adafruit NeoPixel / FastLED | 3 octets par LED (60 LED = 180 octets) | Au démarrage | Limiter 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.
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 ?.
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.
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 ?

| Situation | Recommandation |
|---|---|
| Après F(), PROGMEM et les tableaux char, il reste plus de 300 octets de RAM libre | Reste sur l'Uno ; problème réglé |
| Plusieurs capteurs et un menu avec OLED ou SD, et la RAM ne suffit toujours pas | Arduino Mega 2560 : 4 fois plus de RAM, mêmes broches 5 V et bibliothèques |
| Le programme dépasse 32 Ko mais la RAM suffit | Mega ou Uno R4 : 256 Ko de flash |
| Il te faut du Wi-Fi, un serveur web, de gros tampons ou du traitement d'image | ESP32 : 520 Ko de RAM, 4 Mo de flash, Wi-Fi et Bluetooth |
| Tu veux travailler en MicroPython | Raspberry Pi Pico ou Pico W |
| Un petit nœud capteur qui doit tenir des mois sur piles | Optimise 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ôme | Cause probable | Solution |
|---|---|---|
| Sketch too big, le code ne se téléverse pas | Le programme ne tient pas en flash | Coupe 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 minutes | Les concaténations de String fragmentent le tas | Tableaux char et snprintf au lieu de String ; mesure la RAM libre |
| Caractères incohérents dans le moniteur série, variables qui changent seules | La pile écrase le tas | Ramène la RAM globale sous 75 %, supprime les grands tableaux locaux |
| SSD1306 allocation failed | begin() n'arrive pas à allouer le tampon de 1 Ko | Mets les textes dans F(), passe à U8g2 en mode page |
| La carte redémarre au hasard alors que la mémoire semble correcte | Problème d'alimentation plutôt que de mémoire | Alimente moteurs et relais à part, ajoute un condensateur |
| Les éléments d'un tableau affichent des valeurs absurdes | Écriture au-delà des limites du tableau | Vérifie l'indice ; calcule les limites de boucle avec sizeof |
| Stack canary watchpoint triggered sur l'ESP32 | La pile d'une tâche a débordé | Rends globaux les grands tableaux locaux ou agrandis la pile de la tâche |
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.
Projets à réaliser après cet article
Voir tous les projets
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.

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…

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.

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.

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…

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.

Serrure à code avec clavier 4x4 et écran LCD
Une petite serrure électronique qui ne laisse entrer que ceux qui connaissent le code.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

