Débuter Arduino. Fonctions chaînes de caractères (compatible ESP32 ESP8266)

Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

La librairie C++ pour Arduino propose 24 fonctions pour manipuler très facilement les chaînes de caractères. Ces fonctions sont supportées par le framework ESP-IDF pour les cartes de développement ESP32 ainsi que le SDK pour les cartes ESP8266.

 

Remarques générales

  • L’index du premier caractère d’une chaîne se trouve à la position 0, et non pas 1.
  • On peut être amené à manipuler les chaînes avec des tableaux de bytes. 1 caractère = 1 byte

Accès rapide aux fonctions

charAt compareTo concat c_str endsWith equals getBytes indexOf length remove   replace startsWith setCharAt subString reserve   toCharArray  toLowerCase toUpperCase trim opérateurs

Fonctions C++ pour manipuler les chaînes dans du code Arduino

Tous les fonctions permettant de manipuler les String sont détaillées ici sur le site officiel de la fondation.

charAt(n) permet d’extraire le caractère d’une chaîne à la position n

Serial.println(string1.charAt(2));

compareTo() Compare deux chaînes. Valeur retournée

  • un nombre négatif si myString précède myString2.
  • 0 si les deux chaines sont identiques
  • un nombre positif si myString est situé après myString2
Serial.println(string1.compareTo(string2));

concat() Concatène (assemble) deux chaînes. Le résultat est copié dans la première String

startstring.concat(endstring);
Serial.print(startstring);

Il est aussi possible de concatener des chaînes à l’aide de l’opérateur += comme ceci

String demo = "une";
demo += " chaine ";
demo += "de caractères";

c_str() Convertit le contenu d’une chaîne en une chaîne de type C terminée par un caractère nul ‘\0’.

endsWith() Test si une chaîne se termine ou non par les caractères d’une autre chaîne.
Retourne true si c’est le cas, false dans le cas contraire.

La fonction startsWith() permet de faire la même chose mais depuis le début de la chaîne.

Serial.println(string1.endsWith("manipulation"));

equals() Compare si deux chaînes sont identiques.
Attention, la comparaison est sensible à la casse, c’est à dire qu’il faut faire attention aux majuscules et aux minuscules. La chaîne arduino n’est pas égale à la chaîne ARDUINO.

Pour le pas tenir compte de la casse, utiliser la fonction equalsIgnoreCase()

String string1 = "A string to test Arduino string manipulation";
String string2 = "a string to test Arduino string manipulation";
Serial.println(string1.equals(string2));  // retourne 0, differentes
Serial.println(string1.equalsIgnoreCase(string2)); // retourne 1, identiques

getBytes(buffer, len) Copie chaque caractères de la chaîne dans un buffer (tampon).

La taille len du buffer doit correspondre au nombre de caractères de la chaîne + 1.

String stringtocopy = "ESP8266"; 

// mesure la longueur de la chaine
int buffer_size = stringtocopy.length();
Serial.printf("Buffer size: %u\n", buffer_size);

// Cree un buffer ayant la meme taille que la chaine
byte buffer[buffer_size]; 

// Copie le contenu de la chaine a l'aide de la fonction getBytes
// Attention, il faut ajouter 1 a la taille de la chaine pour ne pas avoir de caractere NULL
stringtocopy.getBytes(buffer, buffer_size + 1); 
Serial.println("Print buffer with write function"); 

// On imprime un a un chaque cellule du buffer a l aide d une boucle for
for (int i = 0; i < buffer_size; i++) { 
  Serial.write(buffer[i]); 
} 
Attention, il faut ajouter 1 à la longueur de la chaîne au niveau du paramètre len, sinon le dernier caractère est null. Voici ce qu’on obtient par exemple : ESP826␀

indexOf(val, from) Cherche la val d’un caractère ou d’une chaîne. Par défaut, la recherche démarre au début de la chaîne. Indiquer la position de départ from pour démarrer la recherche depuis une caractère précis.

La fonction indexOf() retourne la position de la première occurence de la chaîne trouvée et -1 dans le cas contraire.

Remarque, la fonction indexOf() peut renvoyer un résultat incohérent lorsqu’on l’utilise directement dans une autre fonction. Il faut passer par une variable intermédiaire pour récupérer l’index comme dans l’exemple ci-dessous

int posString = string1.indexOf("Arduino");
Serial.println("Position of Arduino string " + String(posString));

length() Renvoie la longueur de la chaîne, en caractères sans le caractère de fin de chaîne ‘\0’.

Serial.println(string1.length());

remove(from, n) Supprime les n caractères de la chaîne depuis l’index from. Le résultat est stocké dans la chaîne initiale.

String demoremove = "hello";
demoremove.remove(2,2);
Serial.println(demoremove);  // devient "heo"

replace() La fonction permet de remplacer toutes les occurrences d’un caractère / chaîne donné par un autre caractère / chaîne.

Attention, la fonction replace() est sensible à la casse
string1.replace("Arduino","ESP32");
Serial.println(string1); 

Pour remplacer uniquement un caractère, on peut aussi utiliser la fonction setCharAt().

startsWith() Test si la chaîne commence par le chaîne passée en paramètre.

Serial.println(string1.startsWith("A text"));

setCharAt( pos, char) Remplace un caractère de la chaîne à la position par un nouveau character.

String stringtomodify = "hello";
char myChar = 'L';  
stringtomodify.setCharAt(2,myChar);
Serial.println(stringtomodify);   // renvoie heLlo

substring(from, to) Extrait une portion de la chaîne depuis l’index from jusqu’au caractère to.
Utiliser la fonction indexOf() pour connaître la position (l’index) d’un caractère ou d’un mot dans la chaîne.

int posString = string1.indexOf("Arduino");
Serial.println("Position of Arduino string " + String(posString));  
// Extrait le mot Arduino dans la chaine
Serial.println(string1.substring(posString, posString + 7));

reserve() permet d’optimiser la mémoire en allouant la taille de la mémoire réservée à une variable de type String.

Remarque, l’allocation n’est pas dynamique. Si la chaîne dépasse la taille réservée, celle-ci sera tronquée.
String myString;
myString.reserve(20);
myString = "a ";
myString += "demo ";
myString += "with a string";
Serial.println(myString);

Forcer en majuscule ou minuscule, supprimer les espaces vides

toLowerCase() force tous les caractères de la chaîne en minuscule

toUpperCase() force tous les caractères de la chaîne en majuscule

trim() supprime tous les espaces au début et à la fin de la chaîne

Fonctions de conversion de chaînes de type String

toCharArray(buffer, len) copie chaque caractère d’une chaîne dans un buffer de taille len.

String stringtocopy = "ESP8266"; 

// mesure la longueur de la chaine
int buffer_size = stringtocopy.length();
Serial.printf("Buffer size: %u\n", buffer_size);

// Cree un buffer ayant la meme taille que la chaine
byte buffer[buffer_size]; 

// Copie le contenu de la chaine a l'aide de la fonction getBytes
// Attention, il faut ajouter 1 a la taille de la chaine pour ne pas avoir de caractere NULL
stringtocopy.getBytes(buffer, buffer_size + 1); 
Serial.println("Print buffer with write function"); 

// On imprime un a un chaque cellule du buffer a l aide d une boucle for
for (int i = 0; i < buffer_size; i++) { 
  Serial.write(buffer[i]); 
} 
Attention, il faut ajouter 1 à la longueur de la chaîne au niveau du paramètre len de la fonction getBytes, sinon le dernier caractère est null. Voici ce qu’on obtient par exemple : ESP826␀

Conversion d’un nombre stocké dans une String

Fonction Usage Exemple
toDouble()

toFloat()

Conversion vers une variable de type double ou float

Par exemple, les chaînes “123.45”, “123” et “123fish” sont converties en 123,45, 123,00 et 123,00 respectivement. La fonction réalise un arrondi, par exemple “123,456” sera arrondi à 123,46. Les flottants n’ont que 6 à 7 chiffres décimaux de précision, par conséquent les chaînes plus longues peuvent être tronquées.

myString.toDouble()
toInt() Conversion d’une chaine en entier
myString.toInt()

Opérateurs autorisés sur les chaînes

Opérateur Utilisation Exemple
[] Accéder à un élément d’un buffer
Serial.write(buffer[i]);
Initialiser un buffer
byte buffer[7];
+ Concatène, assemble deux chaînes
Serial.println("Position of Arduino string " + String(posString));
+= Ajoute à une chaine existante une nouvelle chaîne

 

String demo = "une"; 
demo += " chaine ";
== Comparaison Vrai si les chaînes sont identiques
> Strictement plus grand Utilise les comparateurs mathématiques pour comparer deux chaînes

String first = "abc1234";
String second = "def1234";
Serial.print(" first == second "); Serial.println(first == second);  // 0
Serial.print(" first > second "); Serial.println(first > second);    // 0
Serial.print(" first >= second "); Serial.println(first >= second);  // 0
Serial.print(" first < second "); Serial.println(first > second);    // 0
Serial.print(" first <= second "); Serial.println(first <= second);  // 1
Serial.print(" first != second "); Serial.println(first != second);  // 1

 

< Strictement plus petit
>= Plus grand ou égal
<= Plus petit ou égal
!= Différent

Téléverser le code Arduino pour tester les fonctions

Créer un nouveau croquis sur l’IDE Arduino ou un nouveau projet PlatformIO puis coller le code suivant

#include <Arduino.h> 

String string1 = "A text to test Arduino string manipulation";
String string2 = "a text to test Arduino string manipulation";
String startstring = "Welcome to ";
String endstring = "this new tutorial";
#define string3 "A different string to test Arduino string manipulation"

#define SERIAL_SPEED 115200

void setup() {
  Serial.begin(SERIAL_SPEED);
  Serial.println("===== charAt(n) =====");
  Serial.println(string1.charAt(2));
  
  Serial.println("===== compareTo() =====");
  Serial.print("Same strings "); Serial.println(string1.compareTo(string2));
  Serial.print("Different strings"); Serial.println(string1.compareTo(string3));

  Serial.println("===== concat() =====");
  startstring.concat(endstring);
  Serial.println(startstring);

  Serial.println("===== endsWith() =====");
  Serial.println(string1.endsWith("manipulation"));

  Serial.println("===== equals() / equalsIgnoreCase() =====");
  Serial.println(string1.equals(string2));
  Serial.println(string1.equalsIgnoreCase(string2));

  Serial.println("===== getBytes() =====");
  String stringtocopy = "ESP8266"; 
  // mesure la longueur de la chaine
  int buffer_size = stringtocopy.length();
  Serial.printf("Buffer size: %u\n", buffer_size);
  // Cree un buffer ayant la meme taille que la chaine
  byte buffer[buffer_size]; 
  // Copie le contenu de la chaine a l'aide de la fonction getBytes
  // Attention, il faut ajouter 1 a la taille de la chaine pour ne pas avoir de caractere NULL
  stringtocopy.getBytes(buffer, buffer_size + 1); 
  Serial.println("Print buffer with write function"); 
  // On imprime un a un chaque cellule du buffer a l aide d une boucle for
  for (int i = 0; i < buffer_size; i++) { 
    Serial.write(buffer[i]); 
  }  
  Serial.println("");

  Serial.println("===== indexOf() =====");
  int posString = string1.indexOf("Arduino");
  Serial.println("Position of Arduino string " + String(posString));  
  Serial.println(string1.substring(posString, posString + 7));

  Serial.println("===== length() =====");
  Serial.println(string1.length());

  Serial.println("===== remove() =====");
  String demoremove = "hello";
  demoremove.remove(2,2);
  Serial.println(demoremove);  // devient "heo"

  Serial.println("===== replace() =====");
  string1.replace("Arduino","ESP32");
  Serial.println(string1);  

  Serial.println("===== setCharAt() =====");
  String stringtomodify = "hello";
  char myChar = 'L';  
  stringtomodify.setCharAt(2,myChar);
  Serial.println(stringtomodify); 

  Serial.println("===== startsWith() =====");
  Serial.println(string1.startsWith("A text"));

  Serial.println("===== reserve() =====");
  String myString;
  myString.reserve(20);
  myString = "a ";
  myString += "demo ";
  myString += "with a string";
  Serial.println(myString);

  Serial.println("===== toCharArray() =====");
  String stringtocopy = "Arduino";
  // mesure la longueur de la chaine
  int buffer_size = stringtocopy.length();
  Serial.printf("Buffer size: %u\n", buffer_size);

  // Cree un buffer ayant la meme taille que la chaine
  byte buffer[buffer_size]; 

  // Copie le contenu de la chaine a l'aide de la fonction getBytes
  // Attention, il faut ajouter 1 a la taille de la chaine pour ne pas avoir de caractere NULL
  stringtocopy.getBytes(buffer, buffer_size + 1); 
  Serial.println("Print buffer with write function"); 

  // On imprime un a un chaque cellule du buffer a l aide d une boucle for
  for (int i = 0; i < buffer_size; i++) { 
    Serial.write(buffer[i]); 
  }

  Serial.println("===== < <= > >= =====");
  String first = "abc1234";
  String second = "def1234";
  Serial.print(" first == second "); Serial.println(first == second);  // 0
  Serial.print(" first > second "); Serial.println(first > second);    // 0
  Serial.print(" first >= second "); Serial.println(first >= second);  // 0
  Serial.print(" first < second "); Serial.println(first > second);    // 0
  Serial.print(" first <= second "); Serial.println(first <= second);  // 1
  Serial.print(" first != second "); Serial.println(first != second);  // 1

}

void loop() {
}

Ouvrez le moniteur série pour visualiser les opérations sur les Strings Arduino

===== charAt(n) =====
t
===== compareTo() =====
Same strings -32
Different strings16
===== concat() =====
Welcome to this new tutorial
===== endsWith() =====
1
===== equals() / equalsIgnoreCase() =====
0
1
===== getBytes() =====
Print buffer
Arduin␀
===== indexOf() =====
Position of Arduino string 15
Arduino
===== length() =====
42
===== remove() =====
heo
===== replace() =====
A text to test ESP32 string manipulation
===== setCharAt() =====
heLlo
===== startsWith() =====
1
===== reserve() =====
a demo with a string
===== toCharArray() =====
Print char buffer
ESP8266===== < <= > >= =====
 first == second 0
 first > second 0
 first >= second 0
 first < second 0
 first <= second 1
 first != second 1

Mises à jour

1/10/2020 Publication de l’article

English Version

Avez-vous aimé cet article ?
[Total: 2 Moyenne: 5]
Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Vous avez aimé ce projet ? Ne manquez plus aucun projet en vous abonnant à notre lettre d’information hebdomadaire!

quel modèle esp8266 choisir
Quel modèle d'ESP8266EX choisir en 2020 ?
guide choix esp32 development board
Quel ESP32 choisir en 2020 ?

Vous rencontrez un problème avec ce sujet ?

Peut-être que quelqu’un a déjà trouvé la solution, visitez le forum avant de poser votre question

Nous serions ravis de connaître votre avis

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Domotique et objets connectés à faire soi-même
Vous avez aimé ce tutoriel

Ne manquez plus les prochains projets

Recevez chaque semaine le récapitulatif des tutoriels et projets.

Vous pouvez vous désabonner à tout moment.