String C++. concat•c_srt•indexOf•replace•subString… pour Arduino ESP32 ESP8266

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

Table des matières

La librairie C++ pour Arduino propose 24 fonctions pour manipuler très facilement les chaînes de caractères. charAt • compareTo • concat • c_str • endsWith • equals • getBytes • indexOf • length • remove •  replace • startsWith • setCharAt • subString • reserve • toCharArray • toLowerCase • toUpperCase • trim… Ces fonctions sont supportées par le framework ESP32-Arduino (le wrapper du SDK 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 avec 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

Merci pour votre lecture.

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.

Calculateurs
×
Calculateur loi d'Ohm
Tension (U) - en Volt
Courant (I) - en Ampère
Résistance (R) - en Ohms
Puissance (P) - en Watts

Ce calculateur permet de calculer les relations entre le courant, la tension, la résistance et la puissance dans les circuits résistifs.

Saisir au moins deux valeurs puis cliquer sur calculer pour calculer les valeurs restantes. Réinitialisez après chaque calcul.

Rappel sur la Loi d'Ohm
La loi d'Ohm explique la relation entre la tension, le courant et la résistance en déclarant que le courant traversant un conducteur entre deux points est directement proportionnel à la différence de potentiel entre les deux points.
La loi d'Ohm s'écrit U = IR, où U est la différence de tension, I est le courant en ampère et R est la résistance en Ohms (symbole Ω).
Loi d'Ohm (U=RI)
×
Déchiffrer le code couleur d'une résistance à 4 bandes
Bande 1 Bande 2 Multiplicateur Tolérance
   

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 4 anneaux
Formule : ab*cΩ ±d%
Les deux premières bandes (a, b) permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0) donne le nombre 10.
La troisième bande (c) est un coefficient multiplicateur. Par exemple, l'anneau rouge est un coefficient multiplicateur de 100, ce qui donne 10 X 100 = 1000Ω.
Le quatrième anneau (d) indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que sa valeur soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 4 bandes
×
Déchiffrer le code couleur d'une résistance à 5 bandes
Bande 1 Bande 2 Bande 3 Multiplicateur Tolérance

Résistance:  

1 000 Ω ±5%

Comment déchiffrer le code couleur d'une résistance à 5 anneaux
Formule : abc*dΩ ±e%
Les trois premières bandes permettent de déterminer le chiffre significatif. La première bande correspond au chiffre de la dizaine, le second anneau le chiffre de l'unité. Par exemple Brun(1), Noir (0), Noir (0) donne le nombre 100
La quatrième bande est un coefficient multiplicateur. Par exemple, l'anneau brun correspond au coefficient multiplicateur 10, ce qui donne 100 X 10 = 1000Ω.
Le cinquième anneau indique la tolérance de la valeur nominale de la résistance. Par exemple l'anneau Or correspond à ±5%. Donc le fabricant de la résistance s'engage à ce que la valeur de la résistance soit comprise entre 950 Ω et 1050 Ω.
Déchiffrer code couleur 5 bandes
×
Calculateur de résistance série pour une ou plusieurs LED
Tension d'alimentation en Volt
Tension directe en Volt
Courant en mA
Résistance calculée en Ω
Puissance estimée en W

Ce calculateur permet de déterminer la résistance requise pour piloter une ou plusieurs LED connectées en série à partir d'une source de tension à un niveau de courant spécifié.

Remarque. Il est préférable d'alimenter le circuit avec une puissance nominale comprise entre 2 et 10 fois la valeur calculée afin d'éviter la surchauffe
Couleur Longueur d'onde (nm) Tension (V) pour LED ⌀3mm Tension(V) pour LED ⌀5mm
Rouge 625-630  1,9-2,1 2,1-2,2
Bleu 460-470 3,0-3,2 3,2-3,4
Vert 520-525 2,0-2,2 2,0-2,2
Jaune 585-595 2,0-2,2 3,0-3,2
Blanc 460-470 3,0-3,2 1,9-2,1
Résistance en série pour une ou plusieurs LED
×
Calculateur durée de vie d'une batterie
Capacité de la batterie
Consommation de l'appareil ou objet connecté

Ce calculateur estime la durée de vie d'une batterie, en fonction de sa capacité nominale et du courant ou de la puissance qu'une charge en tire.

La durée de vie de la batterie est une estimation idéalisée. La durée de vie réelle peut varier en fonction de l'état de la batterie, de son âge, de la température, du taux de décharge et d'autres facteurs. C'est le mieux que vous pouvez espérer obtenir.

Autonomie de la batterie = capacité de la batterie en mAh / courant de charge en mA

Durée de vie batterie
Publicité
À lire aussi
Composants
Sur le Forum
Derniers Sujets
Domotique et objets connectés à faire soi-même
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. 

Shopping cart