Bases · 12 min de lecture

Arduino String : chaîne de caractères, substring et toInt

Comment utiliser String sur Arduino ? Concaténation, indexOf, substring, toInt, analyse de commandes série, tableau char, macro F() et fragmentation mémoire.

La classe String d'Arduino est un outil prêt à l'emploi qui te permet de stocker du texte dans une seule variable, de le concaténer et de le découper. C'est le premier réflexe quand tu veux séparer une commande comme "LED,1" reçue sur le port série, afficher une mesure sous la forme "Temperature: 24 C" ou reconnaître un message arrivé par Bluetooth. Sur Arduino, il y a deux façons de gérer du texte : l'objet String, facile à utiliser, et le tableau char, hérité du langage C et de plus bas niveau. Les deux font le même travail, mais n'utilisent pas du tout la mémoire de la même façon.

Dans cet article, tu vas d'abord voir avec de vraies sorties les opérations les plus courantes de String : concaténation, indexOf, substring et toInt. Ensuite, nous écrirons un analyseur qui reçoit des commandes sur le port série, allume et éteint une LED et règle sa luminosité en PWM. Puis nous verrons pourquoi String peut poser problème avec le temps dans les 2 Ko de RAM de l'Arduino Uno, ainsi que la fragmentation mémoire et la macro F(). Dans les dernières parties, tu verras comment écrire le même analyseur avec un tableau char, sur ESP32 et sur Raspberry Pi Pico en MicroPython.

Carte Arduino Uno
Arduino Uno : le processeur ATmega328P n'a que 2 Ko de RAM ; cette limite est déterminante dès que tu manipules du texte.

Qu'est-ce que String sur Arduino et en quoi diffère-t-il d'un tableau char ?

String (avec un S majuscule) est une classe définie dans le noyau Arduino. Elle stocke le texte dans une zone mémoire appelée tas (heap) et agrandit elle-même cet espace quand le texte s'allonge. Cela permet de concaténer avec +, de comparer avec == et de convertir en nombre en une seule commande. Un tableau char, lui, est une zone d'octets de taille fixe que tu définis dès le départ. La fin du texte est toujours marquée par un caractère invisible '\0' (nul) ; c'est pourquoi le mot "Hello" de 5 lettres demande un tableau d'au moins 6 octets : char nom[6] = "Hello";. Avec un tableau char, tu utilises des fonctions C comme strcat et strcmp pour concaténer et comparer ; l'opérateur == compare l'adresse mémoire des deux tableaux, pas leur contenu. Cette distinction est l'un des pièges les plus fréquents des débutants.

CaractéristiqueStringTableau char
Facilité d'utilisationTrès facile : +, ==, substring()Plus difficile : strcat(), strcmp(), strtok()
Emplacement mémoireTas (heap), dynamiqueFixe ; zone globale ou pile (stack)
TailleGrandit toute seuleDéfinie au départ
Risque de dépassementAucun, mais l'opération échoue silencieusement si la mémoire est pleineOui ; c'est à toi de vérifier les limites
Risque de fragmentationOui (surtout sur Uno)Non
Usage adaptéESP32, Pico, textes courts et raresProjets qui tournent en continu sur Uno et Nano

Mémoire selon la carte et connexion de test

CaractéristiqueArduino UnoESP32Raspberry Pi Pico
RAM2 Ko de SRAM520 Ko de SRAM264 Ko de SRAM
Mémoire programme32 Ko de flash4 Mo de flash externe (sur la plupart des cartes)2 Mo de flash externe
Broche de la LED de testD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Vitesse du port série (dans les exemples)9600 bauds115200 baudsUSB (shell de Thonny)
Macro F()Économise de la RAMSans effet, présente pour la compatibilitéN'existe pas (MicroPython)
Type de texteString et char[]String et char[]str (Python)
Si le réglage de fin de ligne en bas à droite du Moniteur série reste sur No line ending, le caractère '\n' n'est pas envoyé quand tu appuies sur Entrée ; ton analyseur, qui attend la fin de ligne, attendra jusqu'au délai d'expiration ou ne se déclenchera jamais. Pour les exemples de cet article, choisis Newline ou Both NL & CR. Avec la seconde option, le caractère '\r' reçu reste collé à la fin du texte ; c'est pourquoi le code utilise trim() ou ignore le caractère '\r'.

Opérations de base avec String : concaténation, indexOf, substring, toInt

Pour ajouter du texte à un String, on utilise += ou concat(). indexOf() te donne la position d'un caractère ou d'un mot ; le comptage commence à 0 et la fonction renvoie -1 si rien n'est trouvé. substring(début, fin) copie une partie du texte : la position de début est incluse, celle de fin est exclue, donc substring(8, 12) prend les caractères aux positions 8, 9, 10 et 11. toInt() convertit les chiffres au début du texte en un nombre de type long. Si tu téléverses le code ci-dessous et ouvres le Moniteur série à 9600 bauds, tu peux comparer chaque ligne de sortie avec la valeur indiquée en commentaire.

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3
4  String ad = "Blue";
5  ad += "Grays";                                  // birleştirme / concatenation
6  String mesaj = "Merhaba " + ad;                 // "Merhaba BlueGrays"
7  int sicaklik = 24;
8  String satir = String("Sicaklik: ") + sicaklik + " C";  // sayı eklemek / appending a number
9
10  Serial.println(mesaj);                          // Merhaba BlueGrays
11  Serial.println(satir);                          // Sicaklik: 24 C
12  Serial.println(mesaj.length());                 // 17
13  Serial.println(mesaj.indexOf(' '));             // 7
14  Serial.println(mesaj.indexOf("Grays"));         // 12
15  Serial.println(mesaj.substring(8));             // BlueGrays
16  Serial.println(mesaj.substring(8, 12));         // Blue
17  mesaj.toUpperCase();                            // yerinde değiştirir / modifies in place
18  Serial.println(mesaj);                          // MERHABA BLUEGRAYS
19
20  String sayiMetni = "1250";
21  long n = sayiMetni.toInt() + 1;                 // 1251
22  Serial.println(n);
23  float f = String("3.75").toFloat();             // 3.75
24  Serial.println(f, 2);
25  Serial.println(String(255, HEX));               // ff
26}
27
28void loop() {
29}
FonctionQue fait-elle ?Exemple (s = "LED,128")
s.length()Renvoie le nombre de caractères7
s.indexOf(',')Position de la première occurrence, -1 sinon3
s.substring(0, 3)De 0 jusqu'à la position 3 (exclue)"LED"
s.substring(4)De la position 4 jusqu'à la fin"128"
s.substring(4).toInt()Convertit en nombre (long) ; 0 si invalide128
s.startsWith("LED")Commence-t-il par ce texte ?true
s.equalsIgnoreCase("led,128")Compare sans tenir compte de la cassetrue
s.charAt(0)Renvoie un seul caractère'L'
s.trim()Supprime les espaces, \r et \n au début et à la fin (en place)Inchangé (pas d'espace)
s.c_str()Renvoie un pointeur lisible comme un tableau charstrcmp(s.c_str(), "LED,128") == 0
String(3.14159, 2)Convertit un nombre décimal en texte avec ce nombre de décimales"3.14"
s.replace(",", ";")Remplace une partie en places vaut maintenant "LED;128"
Attention quand tu ajoutes un nombre à du texte : la ligne String s = "Valeur: " + 5; compile, mais ne fait pas ce que tu attends. Ici, aucun objet String n'existe ; le compilateur ajoute 5 à l'adresse du texte "Valeur: " et s reçoit un fragment absurde du genre ": ". Il faut toujours avoir un String tout à gauche de la chaîne : écris String s = String("Valeur: ") + 5; ou bien String s = "Valeur: "; puis ajoute s += 5;.

Analyser des commandes série pas à pas

  1. Branche la grande patte (anode) de la LED à la broche D9 de l'Uno via une résistance de 220 Ω, et la courte patte à GND. D9 gère le PWM, donc la luminosité est réglable aussi.
  2. Définis le format de commande : COMMANDE,VALEUR. Par exemple, LED,1 allume la LED, LED,0 l'éteint, PWM,128 donne environ la moitié de la luminosité.
  3. Lis la ligne sur le port série jusqu'au caractère Entrée ('\n') et nettoie les caractères invisibles avec trim().
  4. Trouve la virgule avec indexOf(',') ; sépare avec substring() ce qui précède (commande) et ce qui suit (valeur).
  5. Convertis la valeur en nombre avec toInt(), passe la commande en majuscules avec toUpperCase(), compare-la et exécute l'action correspondante.
  6. Après chaque commande, affiche une courte réponse dans le Moniteur série ; tu vois ainsi tout de suite si la commande a été comprise.
C++ (Arduino IDE)
1const int LED_PIN = 9;          // PWM destekli pin / PWM capable pin
2
3void setup() {
4  Serial.begin(9600);
5  Serial.setTimeout(50);        // satır bekleme süresi (ms) / line wait timeout (ms)
6  pinMode(LED_PIN, OUTPUT);
7  Serial.println(F("Komutlar / Commands: LED,1  LED,0  PWM,0-255"));
8}
9
10void loop() {
11  if (Serial.available() > 0) {
12    String satir = Serial.readStringUntil('\n');  // Enter'a kadar oku / read until Enter
13    satir.trim();                                // CR ve boşlukları sil / remove CR and spaces
14    if (satir.length() == 0) return;
15
16    String komut = satir;
17    String deger = "";
18    int virgul = satir.indexOf(',');
19    if (virgul >= 0) {
20      komut = satir.substring(0, virgul);        // virgülden önce / before the comma
21      deger = satir.substring(virgul + 1);       // virgülden sonra / after the comma
22    }
23    komut.toUpperCase();
24    long sayi = deger.toInt();                   // geçersizse 0 / 0 if invalid
25
26    if (komut == "LED") {
27      digitalWrite(LED_PIN, sayi ? HIGH : LOW);
28      Serial.print(F("LED -> "));
29      Serial.println(sayi ? "ACIK / ON" : "KAPALI / OFF");
30    } else if (komut == "PWM") {
31      sayi = constrain(sayi, 0, 255);            // 0-255 arasında tut / keep in 0-255
32      analogWrite(LED_PIN, (int)sayi);
33      Serial.print(F("PWM -> "));
34      Serial.println(sayi);
35    } else {
36      Serial.print(F("Bilinmeyen komut / Unknown command: "));
37      Serial.println(komut);
38    }
39  }
40}

La ligne Serial.setTimeout(50) est importante : par défaut, readStringUntil() attend le caractère suivant pendant 1000 ms ; si la fin de ligne n'arrive pas, le programme se fige une seconde. À 9600 bauds, un caractère arrive en environ 1 ms, donc 50 ms suffisent largement. Si la commande ne contient pas de virgule, indexOf() renvoie -1 ; dans ce cas, on considère toute la ligne comme la commande et la valeur reste vide. Appliquer toInt() à un String vide donne 0. Il y a un piège : toInt() renvoie aussi 0 pour un texte invalide, donc "PWM,abc" et "PWM,0" sont identiques pour ton code. Dans un vrai projet, c'est une bonne habitude de vérifier avec isDigit() que le premier caractère de la valeur est un chiffre. Quant à constrain(), il empêche la valeur PWM de sortir de la plage 0–255.

Fragmentation mémoire : pourquoi String peut bloquer l'Uno ?

Chaque fois qu'un String grandit et que l'espace actuel ne suffit pas, il demande dans le tas une nouvelle zone plus grande, y déplace le texte et libère l'ancienne. Les zones libérées ne sont pas toujours réutilisables ; avec le temps, le tas ressemble à une tranche de gruyère pleine de petits trous. Même avec 300 octets libres au total, si le plus grand bloc continu fait 40 octets, impossible de créer un String de 50 octets. C'est ce qu'on appelle la fragmentation mémoire (heap fragmentation). Dans les 2 Ko de RAM de l'Arduino Uno, le tas grandit vers le haut et la pile (stack) utilisée par les appels de fonctions vers le bas ; quand les deux se rencontrent, les variables sont corrompues, des caractères bizarres apparaissent dans le Moniteur série ou la carte se réinitialise toute seule. Plus sournois encore : quand il n'y a plus de place, l'opération sur String échoue sans erreur, et le texte reste à moitié rempli ou vide après la concaténation. Ces problèmes n'apparaissent souvent qu'après des heures de fonctionnement, donc on ne les remarque pas lors de courts tests sur le bureau.

  • Réserve de la place avec reserve() : pour un String dont tu peux estimer la longueur, écris ligne.reserve(64); dans setup() ; tant que le texte reste dans cette limite, il ne redemande pas de mémoire.
  • Utilise des variables globales ou static : les String recréés à chaque tour de loop() brassent sans cesse le tas ; réutiliser un seul String global est plus sûr.
  • Passe par référence : déclare le paramètre de fonction ainsi : void ecrire(const String &texte) ; passer un String par valeur crée une nouvelle copie à chaque appel.
  • Découpe les longues chaînes : des expressions comme a + b + c + d produisent des objets temporaires ; ajouter pas à pas avec += utilise moins de mémoire temporaire.
  • Affiche directement : si tu veux seulement afficher le texte, enchaîne des Serial.print() au lieu de concaténer ; aucun String n'est alors créé.
  • Pas dans les interruptions : ne crée pas de String dans les fonctions appelées par attachInterrupt() ; l'allocation mémoire n'est pas sûre dans une interruption.

La macro F() pour économiser la RAM sur Uno

Sur les cartes à processeur AVR (Uno, Nano, Mega), chaque texte constant écrit dans le code est copié de la mémoire flash vers la RAM au démarrage du programme. Rien que dix menus de 40 caractères consomment 400 octets, soit un cinquième de la RAM de l'Uno. La macro F("...") laisse le texte dans la flash, et Serial.print() ou lcd.print() le lit à cet endroit. La règle est simple : mets dans F() chaque texte constant que tu affiches dans le Moniteur série ou sur un écran. F() ne fonctionne qu'avec la famille print et les endroits qui le prennent en charge, comme l'ajout à un String ; on ne peut pas la donner directement à des fonctions C comme strcmp(). Le code ci-dessous montre aussi la méthode classique pour mesurer la RAM libre sur les cartes AVR ; tu peux comparer cette valeur avant et après l'utilisation de F().

C++ (Arduino IDE)
1// Yalnız AVR kartlar (Uno, Nano, Mega) / AVR boards only (Uno, Nano, Mega)
2extern int __heap_start, *__brkval;
3
4int bosRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println("Bu metin RAM'e kopyalanir / This text is copied to RAM");
12  Serial.println(F("Bu metin flash'ta kalir / This text stays in flash"));
13
14  String s;
15  s.reserve(40);                 // tek seferde 40 bayt / 40 bytes at once
16  s += F("Sicaklik: ");          // F() String'e de eklenebilir / F() works with String too
17  s += 24;
18  Serial.println(s);
19
20  Serial.print(F("Bos RAM / Free RAM: "));
21  Serial.println(bosRam());
22}
23
24void loop() {
25}

Analyse de commandes sûre avec un tableau char

Dans les projets où la carte doit tourner des jours sans interruption, surtout sur Uno et Nano, rassembler les commandes dans un tableau char de taille fixe est la voie la plus robuste. Le code ci-dessous écrit les caractères reçus un par un dans un tampon de 32 octets, termine la ligne par '\0' à l'arrivée de '\n' et la découpe à la virgule avec strtok(). Quand le tampon est plein, les caractères en trop sont ignorés silencieusement ; il n'y a donc aucun dépassement. Comme le code n'attend nulle part avec delay() ou un délai d'expiration, d'autres tâches dans loop(), comme lire un capteur ou piloter un moteur, continuent sans accroc. Seule différence : la comparaison est sensible à la casse, tu dois donc écrire les commandes en majuscules.

C++ (Arduino IDE)
1const int LED_PIN = 9;
2const byte MAX_UZUNLUK = 32;          // en fazla 31 karakter + '\0' / max 31 chars + '\0'
3char tampon[MAX_UZUNLUK];
4byte konum = 0;
5
6void komutIsle(char *satir) {
7  char *komut = strtok(satir, ",");   // ilk parça / first token
8  char *deger = strtok(NULL, ",");    // ikinci parça / second token
9  if (komut == NULL) return;
10  int sayi = (deger != NULL) ? atoi(deger) : 0;
11
12  if (strcmp(komut, "LED") == 0) {
13    digitalWrite(LED_PIN, sayi ? HIGH : LOW);
14  } else if (strcmp(komut, "PWM") == 0) {
15    sayi = constrain(sayi, 0, 255);
16    analogWrite(LED_PIN, sayi);
17  } else {
18    Serial.print(F("Bilinmeyen / Unknown: "));
19    Serial.println(komut);
20    return;
21  }
22  char cevap[40];
23  snprintf(cevap, sizeof(cevap), "OK %s=%d", komut, sayi);   // taşma korumalı / overflow safe
24  Serial.println(cevap);
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(LED_PIN, OUTPUT);
30}
31
32void loop() {
33  while (Serial.available() > 0) {
34    char c = Serial.read();
35    if (c == '\r') continue;              // CR karakterini atla / skip CR
36    if (c == '\n') {                      // satır bitti / line complete
37      tampon[konum] = '\0';
38      if (konum > 0) komutIsle(tampon);
39      konum = 0;
40    } else if (konum < MAX_UZUNLUK - 1) {
41      tampon[konum++] = c;                // yer varsa ekle / append if there is room
42    }
43  }
44}
FonctionQue fait-elle ?Exemple
strlen(s)Renvoie le nombre de caractères, '\0' exclustrlen("LED") → 3
strncpy(dest, source, n)Copie au maximum n caractèresstrncpy(buf, "PWM", sizeof(buf) - 1)
strcat(dest, source)Ajoute à la fin (il doit y avoir de la place dans dest)strcat(buf, ",128")
strcmp(a, b)Renvoie 0 si les textes sont égauxstrcmp(commande, "LED") == 0
strchr(s, c)Renvoie l'adresse du caractère, NULL s'il est absentstrchr(s, ',')
strtok(s, ",")Découpe le texte au séparateur (modifie l'original)Pour la partie suivante : strtok(NULL, ",")
atoi / atol / atofConvertit le texte en int, long ou doubleatoi("128") → 128
snprintf(buf, taille, ...)Produit du texte formaté, protégé contre le dépassementsnprintf(buf, sizeof(buf), "%d", 42)
dtostrf(nombre, largeur, décimales, buf)Convertit un float en texte (%f ne marche pas sur AVR)dtostrf(3.14159, 4, 2, buf) → "3.14"

String sur ESP32 : pourquoi c'est plus confortable, et où faire attention ?

L'ESP32 dispose de 520 Ko de SRAM, soit environ 260 fois celle de l'Uno. Utiliser String est donc bien plus confortable pour les tâches riches en texte comme un serveur web, du JSON ou des messages MQTT, et l'analyseur String ci-dessus fonctionne tel quel sur ESP32 en mettant LED_PIN à 4 et la vitesse à 115200 bauds. Le String du noyau ESP32 stocke les textes courts directement dans l'objet sans passer par le tas, ce qui réduit la fragmentation pour les petites étiquettes. Les textes constants étant déjà lus depuis la flash, F() ne change rien ici ; elle garde simplement le code compatible avec AVR. Cependant, sur un serveur web allumé pendant des mois, produire de gros String à chaque requête peut entraîner de la fragmentation. Pour la surveiller, ESP.getFreeHeap() donne la mémoire libre totale et ESP.getMaxAllocHeap() le plus grand bloc continu allouable ; si l'écart entre les deux grandit avec le temps, la fragmentation a commencé.

C++ (Arduino IDE)
1String satir;                     // global, tekrar kullanılır / global, reused
2
3void setup() {
4  Serial.begin(115200);
5  satir.reserve(96);              // önceden yer ayır / pre-allocate
6  Serial.printf("Bos heap: %u bayt\n", (unsigned int)ESP.getFreeHeap());
7}
8
9void loop() {
10  static unsigned long son = 0;
11  if (millis() - son >= 2000) {
12    son = millis();
13    int ham = analogRead(34);     // GPIO 34: yalnız giriş, ADC1 / input only, ADC1
14    satir = "t=";
15    satir += millis() / 1000;
16    satir += " s, adc=";
17    satir += ham;
18    satir += ", heap=";
19    satir += (unsigned long)ESP.getFreeHeap();       // toplam boş / total free
20    satir += ", blok=";
21    satir += (unsigned long)ESP.getMaxAllocHeap();   // en büyük blok / largest block
22    Serial.println(satir);
23  }
24}

Raspberry Pi Pico et traitement de texte en MicroPython

En MicroPython, le texte est de type str et, comme en Python, n'est pas modifiable ; chaque opération produit un nouveau texte et le ramasse-miettes nettoie ceux qui ne servent plus. Comme le Pico a 264 Ko de RAM, des tâches comme l'analyse de commandes ne le sollicitent pas du tout. L'équivalent d'indexOf de String est find(), celui de substring est le découpage (ligne[0:3]), celui de toInt est int() et celui de trim est strip(). Le plus pratique est split(",") : il découpe le texte en morceaux en une ligne. Au lieu de renvoyer 0 pour un texte invalide, int() lève une erreur ValueError ; c'est plus sûr que l'ambiguïté de toInt() sur Arduino, mais tu dois attraper l'erreur avec try/except. Branche la LED à GP15 avec une résistance de 220 Ω, exécute le code avec Thonny et tape les commandes dans la fenêtre Shell. Si tu programmes le Pico avec l'IDE Arduino, String et tableau char fonctionnent de la même façon ; la seule différence est l'abondance de RAM.

MicroPython
1import sys
2from machine import Pin, PWM
3
4led = PWM(Pin(15))                          # GP15 + 220 ohm direnç / resistor
5led.freq(1000)
6
7print("Komutlar / Commands: LED,1  LED,0  PWM,0-255")
8
9while True:
10    satir = sys.stdin.readline().strip()    # Enter'a kadar bekler / waits for Enter
11    if not satir:
12        continue
13    parcalar = satir.split(",")             # "PWM,128" -> ["PWM", "128"]
14    komut = parcalar[0].upper()
15    try:
16        deger = int(parcalar[1]) if len(parcalar) > 1 else 0
17    except ValueError:                      # sayı değil / not a number
18        print("Gecersiz sayi / Invalid number:", parcalar[1])
19        continue
20    if komut == "LED":
21        led.duty_u16(65535 if deger else 0)
22        print("LED ->", "ACIK / ON" if deger else "KAPALI / OFF")
23    elif komut == "PWM":
24        deger = max(0, min(255, deger))     # 0-255 arasında tut / keep in 0-255
25        led.duty_u16(deger * 257)           # 0-255 -> 0-65535
26        print("PWM ->", deger)
27    else:
28        print("Bilinmeyen komut / Unknown command:", komut)

Idées de projets avec String et la communication série

  • Contrôle par Bluetooth : traite avec le même analyseur les commandes "LED,1" ou "SERVO,90" venues du téléphone via un module Bluetooth HC-05.
  • Tableau de bord Python : envoie des commandes depuis un script Python sur ton ordinateur et récupère les mesures de l'Arduino ; les détails sont dans l'article communication série Arduino Python.
  • Messagerie entre deux Arduino : avec la communication série UART, une carte envoie une mesure, l'autre analyse la ligne "T,24" et l'affiche à l'écran.
  • Message défilant sur LCD : fais défiler avec substring() le texte saisi sur le port série et affiche-le sur un écran LCD I2C.
  • Rends les réglages permanents : enregistre dans l'EEPROM un seuil reçu par une commande comme "ESIK,500" ; le réglage ne se perd pas même si la carte redémarre.
  • Enregistrement de données vers Excel : envoie les valeurs des capteurs sous forme de lignes séparées par des virgules et transfère-les vers Excel.

Erreurs fréquentes et solutions

SymptômeCauseSolution
La commande n'est jamais détectéeRéglage No line ending ou '\r' resté à la fin du texteChoisis Newline, utilise trim()
1 seconde de retard à chaque commandereadStringUntil() attend le délai par défaut de 1000 msSerial.setTimeout(50) ou lecture caractère par caractère
"PWM,abc" éteint la LEDtoInt() renvoie 0 pour un texte invalideVérifie le premier caractère avec isDigit()
== est toujours faux avec un tableau char== compare l'adresse, pas le contenuUtilise strcmp(a, b) == 0
Caractères absurdes à la fin du texte'\0' manquant dans le tableau char ou tableau trop petitCrée le tableau à la longueur du texte + 1 et termine par '\0'
Blocage ou reset après des heuresFragmentation du tas sur Uno, RAM épuiséeUtilise reserve(), F() et un tableau char
snprintf affiche "?" au lieu du floatLe support de %f est désactivé sur AVRConvertis avec dtostrf()
length() trop grand avec des lettres accentuéesLes lettres comme é, ş, ğ occupent 2 octets en UTF-8Calcule en octets ou utilise l'ASCII
Si tu n'arrives pas à choisir, applique une règle simple : tableau char et F() dans le code qui tourne en continu sur Uno et Nano, String dans les essais et sur ESP32 et Pico. Surveille aussi la ligne "Global variables use ... bytes" affichée par l'IDE Arduino à la fin de la compilation ; sur Uno, si ce taux dépasse 75 %, l'IDE affiche un avertissement de mémoire faible. Pour plus de détails sur les problèmes de mémoire, consulte l'article Arduino mémoire insuffisante.

Quand tu as compris la différence entre String et tableau char, tu peux traiter en toute sécurité n'importe quelle commande série, message Bluetooth ou ligne de capteur. Pour mieux connaître le Moniteur série, lis l'article Moniteur série Arduino, et pour la logique générale des tableaux, l'article Tableaux Arduino (array). Dans l'application BlueGrays, tu peux mettre en pratique ce que tu viens d'apprendre avec des projets d'allumage de LED par Bluetooth depuis le téléphone, de communication série entre deux Arduino et d'affichage de messages sur LCD, avec schémas de câblage et codes pas à pas.

Questions fréquentes

Faut-il utiliser String ou un tableau char sur Arduino ?

Pour de courts essais, sur ESP32 et sur Pico, String est rapide et lisible. Sur une carte à 2 Ko de RAM comme l'Arduino Uno ou Nano, pour un projet qui tourne des jours, un tableau char de taille fixe est plus sûr car il évite totalement la fragmentation mémoire. Tu peux aussi mélanger les deux : la fonction c_str() de String te permet de le lire comme un tableau char.

Comment convertir un String en int sur Arduino ?

Avec un objet String, on utilise texte.toInt() ; le résultat est de type long et les chiffres au début du texte sont lus. Si le texte ne contient pas de nombre, la fonction renvoie 0 ; pour distinguer un vrai 0 d'une saisie erronée, vérifie donc le premier caractère avec isDigit(). Avec un tableau char, atoi(), atol() ou strtol() (qui offre un contrôle d'erreur) font le même travail.

Comment convertir un nombre en String sur Arduino ?

Le plus simple est d'écrire String(nombre) ; String(255, HEX) produit de l'hexadécimal et String(3.14159, 2) un texte à deux décimales. Tu peux aussi ajouter directement à un String existant avec s += nombre. Pour un tableau char, on utilise snprintf() ou itoa() ; sur les cartes AVR, dtostrf() est nécessaire pour les nombres flottants.

À quoi sert la macro F() d'Arduino ?

F() empêche la copie en RAM des textes constants que tu passes à des commandes comme Serial.print() et les fait lire depuis la mémoire flash. Comme l'Arduino Uno n'a que 2 Ko de RAM, elle fait gagner des centaines d'octets avec de longs menus et messages d'avertissement. Sur ESP32 et Pico, les textes constants restent déjà en flash, donc F() ne change rien ; elle n'est là que pour la compatibilité.

Comment Arduino lit-il un texte reçu sur le port série ?

Le plus court est Serial.readStringUntil('\n') pour lire jusqu'au caractère Entrée ; ensuite, nettoie '\r' et les espaces avec trim(). Comme cette fonction attend 1 seconde par défaut, il vaut mieux raccourcir ce délai avec Serial.setTimeout(). Si le programme ne doit jamais attendre, lis les caractères un par un avec Serial.read(), accumule-les dans un tableau char et traite la ligne à l'arrivée de '\n'.

Comment comparer deux String sur Arduino ?

Avec des objets String, l'opérateur == ou equals() compare les contenus ; si tu veux ignorer la casse, utilise equalsIgnoreCase(). Avec des tableaux char, == compare seulement les adresses mémoire et donne un mauvais résultat ; écris plutôt strcmp(a, b) == 0. N'oublie pas de supprimer avec trim() le '\r' à la fin du texte avant de comparer.

Voir tous les projets
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Contrôler une LED depuis un téléphone via Bluetooth
AR-34Débutant
Premium

Contrôler une LED depuis un téléphone via Bluetooth

Une petite répétition pour allumer et éteindre les lumières de ta chambre depuis ton téléphone.

4.8(69)
91
Communication unidirectionnelle entre 2 Arduino
AR-57Intermédiaire
Premium

Communication unidirectionnelle entre 2 Arduino

Tu fais discuter deux Arduino par un seul fil : appuie sur le bouton de l'un et la LED de l'autre s'allume, appuie encore et elle s'éteint.

4.4(37)
50
Communication bidirectionnelle entre 2 Arduino
AR-58Intermédiaire
Premium

Communication bidirectionnelle entre 2 Arduino

Deux Arduino reliés par des fils se parlent : appuie sur le bouton de l'un et la lumière de l'autre s'allume, appuie encore et elle s'éteint.

4.5(20)
26
Afficher un message sur un écran LCD 2x16
AR-29Avancé
Premium

Afficher un message sur un écran LCD 2x16

Ta première étape pour écrire du texte sur un écran. L'écran LCD à deux lignes affiche d'abord un message d'attente, puis écrit un bonjour sur la ligne du haut et tape un mot lettre par lettre sur…

4.6(37)
51
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
Clavier pour développeur Python
AR-66Intermédiaire
Premium

Clavier pour développeur Python

Si tu en as assez de taper sans cesse les mêmes structures quand tu codes, ce petit clavier est fait pour toi.

4.6(35)
45
Voiture contrôlée par Bluetooth avec L298N
AR-80Avancé
Premium

Voiture contrôlée par Bluetooth avec L298N

Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

5.0(39)
66