Le langage Arduino :Les chaînes de caractères « string »

Mise à jour le 11/04/2022 : Une chaîne de caractères (appelée string en anglais) est une suite de caractères, c’est-à-dire un ensemble de symboles faisant partie du jeu de caractères, défini par le code ASCII. Voici donc une chaîne de caractère ou string => « bonjour »

Sommaire :

Ensemble des fonctions pour la manipulation des chaines de caractères.
- String(). Les chaînes de texte peuvent être représentées de deux manières. vous pouvez utiliser le type de données String, qui fait partie du noyau à partir de la version 0019, ou vous pouvez créer une chaîne à partir d’un tableau de type char et le mettre à zéro
  - Le tuto et le code sur les chaines de caractéres
- charAt() . Accéde à un caractère particulier de la chaîne.
- compareTo().Compare deux chaînes en vérifiant si l’une se situe avant ou après l’autre
- concat(). Concatène deux objets String en un seul nouvel objet String.
- endsWith() .Teste si une chaîne se termine ou non par les caractères d’une autre chaîne.
- equals() . Compare deux chaînes pour l’égalité. La comparaison est sensible à la casse, ce qui signifie que la chaîne « hello » n’est pas égale à la chaîne « HELLO ».
- equalsIgnoreCase()
- getBytes().Copie les caractères de la chaîne dans le tampon fourni.
- indexOf() . Localise un caractère ou une chaîne dans une autre chaîne. Par défaut, les recherches sont effectuées depuis le début de la chaîne, mais peuvent également commencer à partir d’un index donné, ce qui permet de localiser toutes les occurrences du caractère ou de la chaîne.
- lastIndexOf().Localise un caractère ou une chaîne dans une autre chaîne. Par défaut, les recherches sont effectuées à partir de la fin de la chaîne, mais peuvent également fonctionner à partir d’un index donné, ce qui permet de localiser toutes les occurrences du caractère ou de la chaîne.
- length().Renvoie la longueur de la chaîne, en caractères. (Notez que cela n’inclut pas un caractère nul final.)
  - Le tuto : Exemple d’utilisation de la fonction length
- remove().Modifiez sur place une chaîne supprimant les caractères de l’index fourni jusqu’à la fin de la chaîne ou de l’index fourni pour indexer le nombre.
- replace().La fonction String replace () vous permet de remplacer toutes les occurrences d’un caractère donné par un autre caractère. Vous pouvez également utiliser replace pour remplacer les sous-chaînes d’une chaîne par une autre sous-chaîne.
- reserve().La fonction String reserve () vous permet d’allouer un tampon en mémoire pour manipuler des chaînes.
- setCharAt().Définit un caractère de la chaîne. N’a aucun effet sur les index en dehors de la longueur existante de la chaîne.
- startsWith()
- substring. Extrait une sous-chaîne d’un objet String .
Opérateur d’ajout de chaîne. Vous pouvez ajouter des chaînes de différentes manières. Cela s’appelle la concaténation .
Exemple d’utilisation sous forme de programme
- Utilisation de la fonction substring et length
Retour au menu -> le langage pour Arduino.

Retour au sommaire

Ensemble des fonctions pour la manipulation des chaines de caractères

– String() –

Les chaînes de texte peuvent être représentées de deux manières. vous pouvez utiliser le type de données String, qui fait partie du noyau à partir de la version 0019, ou vous pouvez créer une chaîne à partir d’un tableau de type char et le mettre à zéro.

Syntaxe :

Tous les éléments suivants sont des déclarations valides pour des chaînes.

char Str1[15];
char Str2[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’};
char Str3[8] = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’, ‘\0’};
char Str4[] = « arduino »;
char Str5[8] = « arduino »;
char Str6[15] = « arduino »;

Possibilités de déclarer des chaînes

Déclarer un tableau de caractères sans l’initialiser comme dans Str1
Déclarez un tableau de caractères (avec un caractère supplémentaire) et le compilateur ajoutera le caractère nul requis, comme dans Str2.
Ajouter explicitement le caractère nul, Str3
Initialiser avec une constante de chaîne entre guillemets; le compilateur dimensionnera le tableau pour l’adapter à la constante de chaîne et à un caractère nul final, Str4
Initialiser le tableau avec une constante de taille et une chaîne explicites, Str5
Initialiser le tableau, en laissant un espace supplémentaire pour une chaîne plus grande, Str6

Terminaison de la chaine nulle

Généralement, les chaînes se terminent par un caractère nul (code ASCII 0). Cela permet aux fonctions (comme Serial.print()) de dire où se trouve la fin d’une chaîne. Sinon, ils continueraient à lire les octets de la mémoire suivants qui ne font pas réellement partie de la chaîne.

Cela signifie que votre chaîne doit avoir suffisamment d’espace pour un caractère de plus que le texte que vous souhaitez qu’elle contienne. C’est pourquoi Str2 et Str5 doivent comporter huit caractères, même si « arduino » n’en contient que sept – la dernière position est automatiquement remplie par un caractère nul. Str4 sera automatiquement dimensionné à huit caractères, un pour l’extra null. Dans Str3, nous avons explicitement inclus le caractère nul (écrit ‘\ 0’) nous-mêmes.

Le code du tuto :

//
//
//=============================================
//
// Les chaines de caracteres
//       partie 1
//
// etude de :
// string / char /
// ajout de chaine ou concaténer
// calcul le nombre de caractéres qui se trouvent dans la chaine
//
// Le 22-03-2022
// Herve Mazelin pour RedOhm sur l'ide 1.8.57.0
//
//=============================================

// -- declaration des variables pour la communication
//             entre le pc et votre Arduino

// variable recevant les données transmises par le moniteur IDE
// char -> Déclare une variable de un octet de mémoire (8 bits) qui contient
// une valeur correspondant à un caractère
char reception_des_donnees ;
// variable recevant une chaine de caracteres
String chaine_caractere ;


// -- declaration des variables
//

int passage_menu = 0 ;
int passage_buffer;

//  Un programme Arduino doit impérativement contenir cette fonction
//  Elle ne sera exécutee une seule fois au démarrage du microcontroleur
//  Elle sert à configurer globalement les entrées sorties
void setup() {

  // initialisation de la connexion série
  // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  while (!Serial) {
    ;
  }


}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()
void loop() {

  // Affichage du menu

  if (passage_menu == 0 ) {
    Serial.println ("------------------------------------------------------------------------");
    Serial.println ("                        Les chaines de caracteres                       ");
    Serial.println ("                                                                        ");
    Serial.println ("  Inscrivez dans le bandeau de l'IDE Arduino une chaîne de caractères   ");
    Serial.println ("------------------------------------------------------------------------");
    passage_menu = 1 ;
  }

  // -- Lecture du port serie

  while (Serial.available() > 0)
  {
    //lecture du buffer
    reception_des_donnees = Serial.read();
    // Il existe deux méthodes pour assembler une chaîne de caractères
    // dans ce cas bien précis
    // 1 -> chaine_caractere += reception_des_donnees ;
    // 2 -> chaine_caractere.concat(reception_des_donnees);
    chaine_caractere.concat(reception_des_donnees) ;
    delay(15);
    // comptage du nombre de passage
    passage_buffer = passage_buffer + 1;
  }


  if ( chaine_caractere != "")
  {
    Serial.print ("Nombre de passage pour vider le buffer => ");
    Serial.println (passage_buffer);
    Serial.print ( chaine_caractere );
    int nombre_de_caractere ( chaine_caractere.length());
    Serial.print ("  "); Serial.print ("Nombre de caractére  ");
    Serial.println ( nombre_de_caractere);
    Serial.println("");
  }

  chaine_caractere = "";
  delay (10);
  passage_buffer = 0;
}

//=============================================

// Les chaines de caracteres

// partie 1

// etude de :

// string / char /

// ajout de chaine ou concaténer

// calcul le nombre de caractéres qui se trouvent dans la chaine

// Le 22-03-2022

// Herve Mazelin pour RedOhm sur l'ide 1.8.57.0

//=============================================

// -- declaration des variables pour la communication

// entre le pc et votre Arduino

// variable recevant les données transmises par le moniteur IDE

// char -> Déclare une variable de un octet de mémoire (8 bits) qui contient

// une valeur correspondant à un caractère

char reception_des_donnees ;

// variable recevant une chaine de caracteres

String chaine_caractere ;

// -- declaration des variables

int passage_menu = 0 ;

int passage_buffer;

// Un programme Arduino doit impérativement contenir cette fonction

// Elle ne sera exécutee une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(9600);

// on attent que le port de communication soit pret

while (!Serial) {

;

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

// Affichage du menu

if (passage_menu == 0 ) {

Serial.println ("------------------------------------------------------------------------");

Serial.println (" Les chaines de caracteres ");

Serial.println (" ");

Serial.println (" Inscrivez dans le bandeau de l'IDE Arduino une chaîne de caractères ");

Serial.println ("------------------------------------------------------------------------");

passage_menu = 1 ;

}

// -- Lecture du port serie

while (Serial.available() > 0)

{

//lecture du buffer

reception_des_donnees = Serial.read();

// Il existe deux méthodes pour assembler une chaîne de caractères

// dans ce cas bien précis

// 1 -> chaine_caractere += reception_des_donnees ;

// 2 -> chaine_caractere.concat(reception_des_donnees);

chaine_caractere.concat(reception_des_donnees) ;

delay(15);

// comptage du nombre de passage

passage_buffer = passage_buffer + 1;

}

if ( chaine_caractere != "")

{

Serial.print ("Nombre de passage pour vider le buffer => ");

Serial.println (passage_buffer);

Serial.print ( chaine_caractere );

int nombre_de_caractere ( chaine_caractere.length());

Serial.print (" "); Serial.print ("Nombre de caractére ");

Serial.println ( nombre_de_caractere);

Serial.println("");

}

chaine_caractere = "";

delay (10);

passage_buffer = 0;

}

Retour au sommaire

– charAt() –

Accédez à un caractère particulier de la chaîne.

Syntaxe : myString.charAt(n)

Paramètres :

myString: une variable de type String.
n : une variable. Autorisé types de données: unsigned int.

Exemple de programme :

Retour au sommaire

– compareTo() –

Compare deux chaînes en vérifiant si l’une se situe avant ou après l’autre, ou si elles sont égales. Les chaînes sont comparées caractère par caractère en utilisant les valeurs ASCII des caractères. Cela signifie, par exemple, que « a » vient avant « b » mais après « A ». Les chiffres viennent avant les lettres.

Syntaxe :

myString.compareTo(myString2)

Paramètres :

myString : une variable de type String.
myString2: une autre variable de type String.

Retour au sommaire

– concat() –

Concatène deux objets String en un seul nouvel objet String.

La concaténation de deux chaînes de caractères consiste à les mettre bout à bout. Le terme peut désigner:

l’opération de concaténer ces chaînes,
le résultat de cette opération.

Exemple :

La concaténation des chaînes « bonjour » et » RedOhm » donne « bonjour RedOhm ».

Syntaxe :

myString.concat(paramètre)

Paramètres :

myString : une variable de type chaine de caractère
paramètre : Types de données autorisés , String, string, char, byte, int, unsigned int, long, unsigned long, float, double,

Il y a plusieurs possibilités d’assembler des chaines entre elles

En additionnant les chaines de caracteres entre elles

//
// RedOhm


String chaine_1 = "moteur";
String chaine_2 = "servo";
String chaine_3= "";

void setup() {
 Serial.begin (9600);
  while(!Serial);

 // --- Il y a plusieurs possibilités d'assembler des chaines entre elles ---
 Serial.println("--- Il y a plusieurs possibilités d'assembler des chaines entre elles ---");
  Serial.println ("");
   // On peut assembler en additionnant les chaines de caracteres entre elles
   chaine_3= chaine_2+chaine_1; 
   Serial.println( "chaine_3 = chaine_2 + chaine_1");
    Serial.println ("soit ");
     Serial.print( chaine_3);
      Serial.print(" = ");
       Serial.print(chaine_2);
        Serial.print(" + "); 
         Serial.print(chaine_1); 
          
}

void loop() {


}

// RedOhm

String chaine_1 = "moteur";

String chaine_2 = "servo";

String chaine_3= "";

void setup() {

Serial.begin (9600);

while(!Serial);

// --- Il y a plusieurs possibilités d'assembler des chaines entre elles ---

Serial.println("--- Il y a plusieurs possibilités d'assembler des chaines entre elles ---");

Serial.println ("");

// On peut assembler en additionnant les chaines de caracteres entre elles

chaine_3= chaine_2+chaine_1;

Serial.println( "chaine_3 = chaine_2 + chaine_1");

Serial.println ("soit ");

Serial.print( chaine_3);

Serial.print(" = ");

Serial.print(chaine_2);

Serial.print(" + ");

Serial.print(chaine_1);

}

void loop() {

}

Assembler plusieurs chaines de caractéres String – RedOhm –

On concatene les chaines de caracteres entre elles

//
// RedOhm

String chaine_1 = "servo";
String chaine_2 = "moteur";

void setup() {
 Serial.begin (9600);
  while(!Serial);

 // --- Il y a plusieurs possibilités d'assembler des chaines entre elles ---
   // Avec la fonction concat()
   // On concatene chaine_1 avec chaine_2 resultat dans chaine_1
   chaine_1.concat(chaine_2); 
         // Affichage du resultat obtenu avec la commande concat  
         Serial.print(chaine_1); 
          
}

void loop() {

}

// RedOhm

String chaine_1 = "servo";

String chaine_2 = "moteur";

void setup() {

Serial.begin (9600);

while(!Serial);

// --- Il y a plusieurs possibilités d'assembler des chaines entre elles ---

// Avec la fonction concat()

// On concatene chaine_1 avec chaine_2 resultat dans chaine_1

chaine_1.concat(chaine_2);

// Affichage du resultat obtenu avec la commande concat

Serial.print(chaine_1);

}

void loop() {

}

Retour au sommaire

– indexOf() –

Localise un caractère ou une chaîne dans une autre chaîne. Par défaut, les recherches sont effectuées depuis le début de la chaîne, mais peuvent également commencer à partir d’un index donné, ce qui permet de localiser toutes les occurrences du caractère ou de la chaîne.

Syntaxe :

myString.indexOf(val)
myString.indexOf(val, from)

Parameters

myString : une variable de type String.
val : la valeur à rechercher. Types de données autorisés: char, String.
from : l’index à partir duquel lancer la recherche.

Retour au sommaire

– substring() –

Obtenez une sous-chaîne d’une chaîne. L’index de départ est inclusif (le caractère correspondant est inclus dans la sous-chaîne), mais l’index final facultatif est exclusif (le caractère correspondant n’est pas inclus dans la sous-chaîne). Si l’index de fin est omis, la sous-chaîne continue jusqu’à la fin de la chaîne.

Syntaxe :

myString.substring(from)
myString.substring(from, to)

Paramètres :

myString: une variable de type String

from: l’index pour démarrer la sous-chaîne à

to (facultatif): l’index pour terminer la sous-chaîne avant

Retour au sommaire

Exemple 1 : Utilisation de la fonction substring et length

Le tuto :

comment faire apparaître une chaîne de caractères en affichant les lettres les unes derrière les autres.
Pour cela, nous devrons compter le nombre de caractères que compose cette chaîne
Il nous faudra aussi appréhender comment extraire un caractère avec la fonction substring.Et enfin, faire apparaître cette chaîne de caractères en affichant les lettres une à une avec une temporisation entre chaque.Ce qui nous permet de mettre en avant les fonctions suivantes substring() , length()

Le code du tuto :

//
//
//=================================================
//
// Les chaines de caracteres
//       partie 2
//
// etude de la fonction : length(),substring(),
//
// Nous allons étudier dans ce tutoriel comment faire
// apparaître une chaîne de caractères en affichant les
// lettres les unes derrière les autres
//
//
// Le 25-03-2022
// Herve Mazelin pour RedOhm sur l'ide 1.8.57.0
//
//=================================================


// variable recevant une chaine de caracteres avec l'objet string
String chaine_caractere  = "Un grand guerrier ? Personne par la guerre ne devient grand" ;

// -- declaration des variables pour le passage

// Variable pour le passage dans le menu
int passage_menu = 0 ;
// Variable pour le comptage du nombre de caractere
int nombre_de_lettre = 0 ;


void setup() {
  // initialisation de la connexion série
  // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  while (!Serial) {
    ;
  }
  delay(2000);
}

void loop() {
  if (passage_menu == 0 ) {
    Serial.println ("------------------------------------------------------------------------");
    Serial.println ("                        Les chaines de caracteres                       ");
    Serial.println ("                                                                        ");
    Serial.println ("  Etude de la fonction :  length(),substring,                           ");
    Serial.println ("------------------------------------------------------------------------");
    Serial.println (" "); // creation d'une ligne vide


    delay(2000);
    // affichage de la chaine de caracteres
    Serial.print ("Affichage du contenu de la variable chaine_caractere => ");
    Serial.println (chaine_caractere);
    Serial.println(" "); // creation d'une ligne vide

    // Nous allons compter le nombre de caractères composant notre chaîne
    Serial.print("Calcul de la longueur de la chaine de chaine_caractere => ");
    Serial.println(chaine_caractere.length());
    Serial.println(" "); // creation d'une ligne vide

    // on peut aussi transferer la valeur mesurée à une variable
    // nombre qui va nous servir pour reafficher le texte en cours
    nombre_de_lettre = chaine_caractere.length();
    // affichage du texte qui nous defini l'operation en cours

    // Principe d'une boucle qui va nous permetre de faire defiler les caracteres
    // de la phrase 1 par 1
    // for(/*initialisation de la variable*/ ; /*condition de la boucle*/  ; /*instruction à
    for (int compteur = 0 ; compteur < nombre_de_lettre ; compteur++)
    {
      // utilisation de la fonction substring pour extraire une lettre
      // Fonction substring =>
      // Extrait une sous-chaîne d'un objet String. L'emplacement de début est inclusif
      // le caractère correspondant est inclut dans la sous-chaîne
      //
      // Syntaxe => string.substring(debut,fin)
      //
      // la boucle for nous permet d'extraire les lettres une à une en incrementant
      // le debut et la fin de l'extration
      Serial.print (chaine_caractere.substring( compteur, 1 + compteur));
      delay (500);
    }
    passage_menu = 1 ;
  }
}

//=================================================

// Les chaines de caracteres

// partie 2

// etude de la fonction : length(),substring(),

// Nous allons étudier dans ce tutoriel comment faire

// apparaître une chaîne de caractères en affichant les

// lettres les unes derrière les autres

// Le 25-03-2022

// Herve Mazelin pour RedOhm sur l'ide 1.8.57.0

//=================================================

// variable recevant une chaine de caracteres avec l'objet string

String chaine_caractere = "Un grand guerrier ? Personne par la guerre ne devient grand" ;

// -- declaration des variables pour le passage

// Variable pour le passage dans le menu

int passage_menu = 0 ;

// Variable pour le comptage du nombre de caractere

int nombre_de_lettre = 0 ;

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(9600);

// on attent que le port de communication soit pret

while (!Serial) {

;

}

delay(2000);

}

void loop() {

if (passage_menu == 0 ) {

Serial.println ("------------------------------------------------------------------------");

Serial.println (" Les chaines de caracteres ");

Serial.println (" ");

Serial.println (" Etude de la fonction : length(),substring, ");

Serial.println ("------------------------------------------------------------------------");

Serial.println (" "); // creation d'une ligne vide

delay(2000);

// affichage de la chaine de caracteres

Serial.print ("Affichage du contenu de la variable chaine_caractere => ");

Serial.println (chaine_caractere);

Serial.println(" "); // creation d'une ligne vide

// Nous allons compter le nombre de caractères composant notre chaîne

Serial.print("Calcul de la longueur de la chaine de chaine_caractere => ");

Serial.println(chaine_caractere.length());

Serial.println(" "); // creation d'une ligne vide

// on peut aussi transferer la valeur mesurée à une variable

// nombre qui va nous servir pour reafficher le texte en cours

nombre_de_lettre = chaine_caractere.length();

// affichage du texte qui nous defini l'operation en cours

// Principe d'une boucle qui va nous permetre de faire defiler les caracteres

// de la phrase 1 par 1

// for(/*initialisation de la variable*/ ; /*condition de la boucle*/ ; /*instruction à

for (int compteur = 0 ; compteur < nombre_de_lettre ; compteur++)

{

// utilisation de la fonction substring pour extraire une lettre

// Fonction substring =>

// Extrait une sous-chaîne d'un objet String. L'emplacement de début est inclusif

// le caractère correspondant est inclut dans la sous-chaîne

// Syntaxe => string.substring(debut,fin)

// la boucle for nous permet d'extraire les lettres une à une en incrementant

// le debut et la fin de l'extration

Serial.print (chaine_caractere.substring( compteur, 1 + compteur));

delay (500);

}

passage_menu = 1 ;

}

Retour au sommaire