Comment puis-je compter le nombre de virgule dans un String

Bonjour à tous!

Je cherche à faire un truc de simple :slight_smile:
J’ai un String

String sms_pos;

qui affiche ceci

2,4,5,6,7,8,9,10,11,12,13,14,15,

J’ai besoin de compter le nombre de virgule.
Dans ce cas, je devrais pouvoir afficher le chiffre 13

Merciiiiis

En effet,
Voici la solution que j'ai trouvé

  // Count number of comma
  int count=0;
  int count_comma;
  int strlength = ligne.length();
  
  do
  {
      if(String(ligne[count]) == ",")
      {
        count_comma++;
      }
      count++;
    
  }while(count < strlength);
  
  Serial.print(F("Nombre de virgules: ")); Serial.println(count_comma);

Ok,
Je peux te poser une question qui me fait honte?
Ca m’énerve de bloqué la dessus et je crois que je vais revoir une pertie de mon code.

j’ai une array qui contient des valeurs comme par exemple

spliedString[0]="2";
splitedString[1]="4";
splitedString[2]="5";
splitedString[3]="10";
splitedString[4]="11";
splitedString[5]="12";

J’aimerais, de manière simple trouver le nombre de ligne.
Dans l’exemple ci-dessous, je dois avoir : 6

si je fait

sizeof(splitedString);

il me retournera 8, parce qu’il compte 4,5,1,0,1,1,1,2
Si je fais strlength, ca bug

C’est vraiment une question null, mais voilà.

En fait c’est pour le mettre dans un for

for(int i=0; i<sizeof(splitedString); i++)
{
Serial.println(splitedString[i]);
}

Y a pas myoen de faire plus simple?

C'est pas pour être blessant mais j'ai l'impression que tu avances sans méthode.
Tu prends une chaîne, tu la découpes, tu bricoles les trucs après tu cherches une info que tu aurais pu extraire dès le début.
J'ai le sentiment que tu t'es lancé dans ton programme sans trop faire de plan avant.

C'est pendant le découpage de la chaîne qu'il faut compter le nombre de sous-chaînes. Lors du découpage, l'index du tableau te fourni l'information sur le nombre de sous-chaînes.

Bonjour,

Je vois que le sujet est marqué comme résolu, mais à mes yeux j'ai l'impression qu'il n'est pas du tout résolu ...

Tu fais les choses à l'envers.
Tu comptes le nombre de "morceaux" dans ta string, morceaux séparés par des virgules, puis tu veux les avoir dans des string séparées.

C'est une mauvaise façon de faire en embarqué. Tu n'as pas assez de mémoire RAM pour te permettre de tout garder en mémoire et d'en faire des copies à tort et à travers.

La "bonne" solution consiste à prendre ta string. A chercher la première virgule disponible. A mettre de côté ce qui se trouve avant cette virgule. Puis à traiter ce morceau (ici je suppose que tu vas vouloir convertir le nombre en un int ?) avant de passer au morceau suivant.
Ainsi tu ne garde en mémoire que la string de base et le(s) résultat(s) à tout instant t, mais pas plus.

Tu l'auras compris, je suis du même avis que fdufnews.
Tu prend les choses comme elles viennent sans avoir de plan. Ou alors tu as oublié de nous présenter ton plan et la finalité de ton code :wink:

Bonjour,
Je vous remercie à tous pour vos observations et oui en effet, peut-être que je ne m’y suis pas pris dans le bon sens.
Dans le soucis de bien faire, je pense que je dois me repencher la dessus.

Pour résumer:

Je veux lire les SMS recus et non lus. Pour cela, j’utilise une commande AT

"AT+CMGL=\"REC UNREAD\",1"

Le 1 pour que le message garde son status unread.

Ceci retourne plusiseurs lignes comme ceci:

+CMGL: 2,“REC UNREAD”,"+41761112200","",“14/09/25,13:25:42+08”
Message

+CMGL: 4,“REC UNREAD”,"+41761112200","",“14/09/25,13:25:42+08”
Message

+CMGL: 10,“REC UNREAD”,"+41761110099","",“14/09/25,13:25:42+08”
Message

et je dois recupérer les chiffres qui se trouvent avant la virgule. Ce chiffre correspond à la position du message.

Je souhaite donc stocker ces chiffres dans un array pour faire une boucle et lire les messages avec la commande AT

char cmd[12];
  // Defini la command
  sprintf(cmd,"AT+CMGR=%d,1",sms_pos);

%d étant la position du message.

J’ai donc bien galéré, avant mon petit niveau pour arriver à ceci, mais je suis d’accord que j’ai mal du m’y prendre. (j’espère que je fournirai assez de code).

J’ai essayé de travailler avec des char, mais je ne suis pas arrivé et j’ai finalement utilisé

sms_pos.concat()

qui m’a permis d’utiliser moin de lignes de code. Mais encore une fois, peut-être que je n’ai pas fait un bon choix.
Au final, sms_pos m’affiche ceci. sms_pos est un String

2,4,5,6,7,8,9,10,11,12,13,14,15,

Jusqu’à là, je suis content, mais si peut-être on peut mieux faire. Je serai encore plus content pour une meilleur suggestion. Maintenant je dois convertir en int pour faire une boucle comme par exemple

for(int pos=0; pos < mesPositions; pos++]) // la grandeur de l'array peut varier en fonction des messsages en mémoire
{
  sms_read(mesPositions[pos]);
}

la fonction sms_read()aura donc la partie de code que je vous ai mis ci-dessus, pour lire les SMS

Pour cela je suis arriver à faire cette fonction, que je vais commenter. La premiere partie n’est pas importante. Elle me permet juste de lister les messages lus, pas lus en fonction de ce que je tape dans mon terminal.

void sms_list(int mode)
{
  byte cmdsize;
// CECI ME PERMETTRA DE DETERMINER LA TAILLE DE MON CHAR cmd
  if(mode == 1)
  {
    cmdsize = 23;
  }
  else if(mode == 2)
  {
    cmdsize = 21;
  }
  else if(mode == 3)
  {
    cmdsize = 16;
  }
  else
  {
    cmdsize = 23;
  }
  // MON CHAR cmd (j'ai deja tenu compte du dernier \0
  char cmd[cmdsize];
  
  // JE DEFINIS MA COMMANDE EN FONCTION DU MODE
  if(mode == 1)
  {
    strcpy(cmd,"AT+CMGL=\"REC UNREAD\",1");
  }
  else if(mode == 2)
  {
    strcpy(cmd,"AT+CMGL=\"REC READ\",1");
  }
  else if(mode == 3)
  {
    strcpy(cmd,"AT+CMGL=\"ALL\",1");
  }
  else
  {
    strcpy(cmd,"AT+CMGL=\"REC UNREAD\",1");
  }
  
  //Serial.print("COMAND:"); Serial.println(cmd);
  
  sms_indicator(); // "AT+CNMI=1,1,0,0,0"
  sms_mode(); // "AT+CMGF=1" (Passe le sim908 en mode texte)
  sms_storage(); // "AT+CPMS=\"SM\",\"SM\",\"SM\"" (Defini le mode de sauvegarde des SMS)
      
  // J'ENVOIE MA COMMANDE POUR LISTER LES SMS RECUS
  Serial1.println(cmd); 
  // PERMET DE SORTIR DU WHILE, CI-DESSOUS, SI LA REPONSE OK EST LUE
  char expected_answer1[]="OK";
  // DEFINI UN MASK QUI ME PERMETTRA D'EXTRAIRE LE/S CHIFFRE/S QUI SUIT
  char replyCommand [7] = {'+','C','M','G','L',':',' '};
   
   uint8_t x=0, answer=0;
   // POUR LE TIMING
    unsigned long previous;
    // VIDE LE BUFFER char buffer[BUFFERSIZE]; qui est defini avant le setup
    memset(buffer, '\0', BUFFERSIZE);    // Initialize the string

    while(Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    
    previous = millis(); // POUR LE TIMING
    int timeout = 5000; // QUITTE WHILE APRES 5 SEC
    int count_message = 0; // COMPTE LES MESSAGE RECU
    String sms_pos; // COLLECTE LA POSITION DES MESSAGES RECUS
    int y = 0; //VOIR PLUS BAS
    int ma = 0;  // VOIR PLUS BAS

    // QUAND LA COMMANDE POUR LISTER LES MESSAGES RECUS, ICI IL ECOUTE LA REPONSE ET STOCK DANS BUFFER
    do{
        if(Serial1.available() > 0){
          if(x < BUFFERSIZE-1) // Do not fill the buffer more the it size
          {
              buffer[x] = Serial1.read(); // response
              //Serial.print(x); Serial.print(F(":")); Serial.println(buffer[x]);
            
             // S'IL LIT LES LETTRES DU MAKS, A LA SUITE, Y PASSE A 1. EN EFFET CECI ME PERMET DE LIRE LE CARACTER QUI SUIT LE
            // MASK, QUI CORRESPOND A LA POSITION DU MESSAGE STOCKE
              if(y)
              {
                if(String(buffer[x]) == ",")
                {
                 // S'IL LIT UNE VIRGULE, IL A LU LA POSITION QU'IL AIT UN OU DEUX DIGIT
                  sms_pos.concat(","); 
                 // DONC UNE NOUVELLE POSITION SERA MEMORISéE
                  count_message++;
                  // REMET LE FLAG Y A 0 CAR IL DOIT RECOMMENCER A DETECTER LES LETTRES QUI SE 
                  // SUIVENT +CMGL:<espace>
                  y=0; 
                }
                else
                {
                // SI NON, BEN AJOUTE LES CHIFFRES LUS. CES CHIFFRES CORRESPONDENT DONC AUX POSITIONS DES SMSs
                sms_pos.concat(buffer[x]);
                }
              }
           
              //'+','C','M','G','L',':',' '
              // COMPARE LA REPONSE DE LA COMMANDE AT+CMGL="REC UNREAD",1
              // SI LA PREMIERE COMPARAISON EST TRUE, INCREMENT ma
              // SI LA DEUXIEME COMPARAISON EST TRUE INCREMENT ma
              // SI LA 3eme ET JUSQUA LA 6, INCREMENTE ma
              // AUSSI TO QUE 1 à 6 EST FAUX, REMET ma A 0

              // PLUS HAUT DANS LE CODE, IL Y A UN CONDITION QUI CONTROLE Y. SI Y EST TROUVE IL MEMORISE 
              // LES POSITIONS DES SMS
              if (buffer[x] == replyCommand[ma])    
              { 
                if(ma==6)
                {
                  y=1;
                   
                }
                else
                {
                  y=0;
                }
                ma++;
          
              }
              else
              {
                ma = 0;
              }
              
            
            x++;
            // SI OK EST LU DANS LA REPONSE, IL QUITTE LA BOUCLE
            if (strstr(buffer, expected_answer1) != NULL)    
              { 
                 answer = 1;
              }
            
          }
        }
        // Waits for the asnwer with time out
    }
    // SI TIMEOUT EST DEPASSER IL QUITTE LA BOUCLE
    while((answer == 0) && ((millis() - previous) < timeout));  
   
// DEBUG: J'AFFICHE LE NOMBRE DE MESSAGE RECU
   Serial.print(count_message); Serial.println(F(" messages")); 
// DEBUG: J'AFFICHE LE NOMBRE DE POSITIONS MéMORISéS DANS sms_pos QUI EST UN STRING
   Serial.println(sms_pos);
   //Serial.println(sms_pos.length());

// MAINTENANT JE DOIS EXPLOITER LES POSITIONS ET LES CONVERTIR EN INT
// CETTE FUNCTION ME PERMETS DE LE FAIRE. JE METS LE CODE PLUS BAS
   splitString(sms_pos, splitedString);
   int w=0;
 
   
   for(w=0; w < NBVALS; w++)
   {
     // N'AFFICHE QUE LES ARRAY QUI ONT UN CHIFFRE
    // char splitedString[15] EST DEFINI AVANT LE SETUP. MAIS C'EST PAS LE TOP, CAR SI J'AI 16 MESSAGES NON LUS, CA BUG
    // J'AI MIS String(splitedString[w]) car je n'ai pas reussi à lire le \0 autrement
     if(String(splitedString[w]) != '\0')
     {
      // DEBUG
       Serial.print(atoi(splitedString[w]));
       Serial.print(F(":"));
       int po = atoi(splitedString[w]);
       Serial.println(po);
 
       sms_read(po,sms_from_number,sms_date,sms_time,sms_text);
       po=0;
       
     }
    
     
   }

 // DEBUG  
  Serial.println(F("-----"));
  Serial.println(w);
  
}

voilà, j’espère que vous pourrez m’aider à optimiser ceci, mais ca vous fait beaucoup de lecture.

Pour en donner plus, voici la fonction qui me permet de spliter mon String sms_pos
J’en suis pas convaincu à 100%, mais j’ai fait de mon mieux et pour le moment ca me retourne ce que j’ai besoin

void splitString(String ligne, char **splitedString)
{
  // Count number of comma
  int count=0;
  int count_comma;
  int strlength = ligne.length();
  
  do
  {
      if(String(ligne[count]) == ",")
      {
        count_comma++;
      }
      count++;
    
  }while(count < strlength);
  
  memset(splitedString,'\0',NBVALS);
  
  // Put into a char
  char *p = strcpy((char*)malloc(count_comma+1), ligne.c_str());

  int i = 0;
  splitedString[i++] = p;
  while (*p) {
    if (*p==',') {
      *p++ = '\0';
      if (i<NBVALS){
         splitedString[i++] = p;
      }
    } 
    else
    {
      p++;
    }
 
  }
  while(i<NBVALS){
    splitedString[i++] = p; 
  }
  
}

En effet, si vous pouviez m’aider à optimiser ceci, ca serait super COOOL. Mais je suis conscient que ca fait peut etre beaucoup.

En tout cas, milles mercis!!!

Bonjour à tous,
Je suis vraiment bloqué et je perds patience.
Ca serait cool, si l’un de vous pouvais m’aider.

Je refais mon code “en plus simple” et le mets avec des commentaires en majuscule.
Ce qui me rend fou, c’est que ca macrhe quand je n’inclu pas la fonction

sms_read()

Par contre quand j’appelle cette meme fonction différemment, elle fonctionne.

Voici donc mon code.
Ce code me permet de tapper dans mon terminal sms,r pour lire les messages ou pour lister les nouveau message messages quand je tape dans mon terminal sms,r ou sms,l

void loop()
{
    serialhwread();
}

void serialhwread(void)
{
  int i=0;
  char inSerial[5]; //inSerial[20]
  boolean error = false;
  
  if (Serial.available() > 0){   
      while (Serial.available() > 0) {
        inSerial[i]=(Serial.read());
        delay(10);
        i++;      
       }
    
    inSerial[i]='\0';
     
      if(!strncmp(inSerial,"sms",3))
      {
        splitString(inSerial,splitedString);
        if(!strncmp(splitedString[1],"r",1))
        {
          
            for(int m=1; m<=18;m++)
            {
            // LIT 18 PREMIERS MESSAGE
              sms_read(m,sms_from_number,sms_date,sms_time,sms_text);
             }
          
        }
        else if(!strncmp(splitedString[1],"l",1))
        {
          // LISTE LES MESSAGE
           sms_list(1);
        }
      }
    
    // Vide inSerial
    inSerial[0]='\0';
  }
}

Cette fonction me permet de lires message et stocker la position des messages dans un varaible int,
le mode 1 est fixé plus haut sms_list(1);

void sms_list(int mode)
{
  byte cmdsize;
  if(mode == 1) // DANS CE CAS, QUE LE MODE 1 EST UTILISé
  {
   // TAILLE DE LA VARIABLE cmd EN FONCTION DE LA COMMANDE AT. VOIR PLUS BAS
    cmdsize = 23;
  }
  else if(mode == 2)
  {
    cmdsize = 21;
  }
  else if(mode == 3)
  {
    cmdsize = 16;
  }
  else
  {
    cmdsize = 23;
  }
  // J AI LA TAILLE, DONC JE DEFINI LA VATIABLE cmd
  char cmd[cmdsize];
  
  if(mode == 1)
  {
    strcpy(cmd,"AT+CMGL=\"REC UNREAD\",1");  // JE "REMPLIS" LA VARIABLE
  }
  else if(mode == 2)
  {
    strcpy(cmd,"AT+CMGL=\"REC READ\",1");
  }
  else if(mode == 3)
  {
    strcpy(cmd,"AT+CMGL=\"ALL\",1");
  }
  else
  {
    strcpy(cmd,"AT+CMGL=\"REC UNREAD\",1");
  }
   
  // JE LANCE LA COMMANDE
  Serial1.println(cmd); 
  // CARCATERE QUI TERMINE LA REPONSE. QUAND IL EST RECU, JE SORS DE MA BOUCLE, VOIR PLUS BAS
  char expected_answer1[]="OK";
  //MASK. JE VEUX RECUPERER LE CARACTERE QUI SUIS L'ESPACE APRES LE :
  char replyCommand [7] = {'+','C','M','G','L',':',' '};
    uint8_t x=0, answer=0;

    //char buffer[BUFFERSIZE]; // CECI EST DIFNI AVANT LE SETUP. BUFFERSIZE EST A 400
    unsigned long previous; // POUR LE TIMEOUT POUR QUITTER LA BOUCLE WHILE

    memset(buffer, '\0', BUFFERSIZE);    // Initialize the string

    while(Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    int y = 0;
    previous = millis();
    int timeout = 5000;
    int count_message = 0;
    String sms_pos;  // POUR ENREGISTRER LES POSITIONS EN STRING
    int ma = 0;

    // J'ECOUTE LA REPONSE
    do{
        if(Serial1.available() > 0){
          // POUR EVITER QUE E BUFFER EXPLOSE S IL Y A TROP DE CARACTERES
          if(x < BUFFERSIZE-1) // Do not fill the buffer more the it size
          {
              buffer[x] = Serial1.read(); // response
              //Serial.print(x); Serial.print(F(":")); Serial.println(buffer[x]);
            
              if(y) // S IL Y A EU 6 IDENTIQUE CARATERE LU A LA SUITE, CONTINUE
              {
                if(String(buffer[x]) == ",") // S IL Y A UNE VIRGULE, CONCAT UNE VIRGULE
                {
                  //Serial.print(F("|"));
                  sms_pos.concat(",");
                  count_message++;
                  y=0; // S IL Y A UNE VIRGULE REPASSE LE FLAG Y A ZERO, POUR LA PROCHAINE POSITION
                }
                else
                {
                // MET DANS LE STRING SMS_POS LE CARACTERE QUI LIT
                sms_pos.concat(buffer[x]);
                }
              }
           
              //'+','C','M','G','L',':',' '
              // SI LES PREMIER CARACTERE CORRESPONS AU PREMIER DU MASK
             // LE BUT DE CETTE MANIPULATION EST DE S'ASSURER QUE LES CARCATERE QUI SE SUIVENT CORRESPOND AU MASK
              if (buffer[x] == replyCommand[ma])    
              { 
                if(ma==6) // SI LE ma A REUSSI A INCREMNTER JUSQU A 6, C EST QUE LES SIX CARACTERE QUI ONT ETE LU A LA SUITE SONT IDENTIQUES AU MASK
                {
                  y=1;  // DONC PASS LE FLAG Y A 1
                   
                }
                else  // SI PASSE A ZERO
                {
                  y=0;
                }
                // SI LE CACATERE QUI SUIT LE PRECEDENT EST IDENTIQUE AU MASK, INCREMENTE. SI PAR EXEMPLE, LE 4EME CARCATERES N EST PAS IDENTIQUE AU MASK. ma REPASSE A ZERO
                ma++;
          
              }
              else
              {
                ma = 0;
              }
              
            
            x++;
            // S'IL LIT OK, SORT DE LA BOUCLE
            if (strstr(buffer, expected_answer1) != NULL)    
              { 
                 answer = 1;
              }
            
          }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < timeout));  
    
    memset(buffer,'\0',BUFFERSIZE); // VIDE LE BUFFER, ON EN A PLUS BESOIN
    

// sms_pos EST SOUS CETTE FORME : 2,4,5,6,7,8,10,11,12,13,14,15,16,17,18,
   #ifdef DEBUG_SMS
     Serial.print(F("> "));Serial.print(count_message); Serial.println(F(" received messages")); 
     Serial.print(F("  SMS positions: ")); Serial.println(sms_pos);
     Serial.println(F("\n"));
   #endif  

// JUSQU A LA, CA FONCTIONNE TRES BIEN
   
// MAINTENANT JE DOIS COMPTER LE NOMBRE DE VIRGULE. CE QUI ME PERMETTRA AUSSI DE SAVOIR LE NOMBRE DE MESSAGE
   // Count number of comma in string
  int count=0;
  int count_comma = 0;
  int strlength = sms_pos.length();        // Count length of sms_pos
  //Serial.print(F("sms_pos len: ")); Serial.println(strlength);
  
  do
  {
      if(sms_pos.charAt(count) == ',')
      {
        count_comma++;
      }
      count++;
    
  }while(count < strlength);

  // JUSQU'ICI CA MARCHE TRES BIEN

  // ENREGISTRE ES POSITION DANS UN ARRAY DE TYPE INT
  int smspositions[count_comma-1];
  String smspositions_str
  count=0;
  int p = 0;
  
  do // JE FAIS TANT QUE....
  {
    // S IL RENCONTRE  UNE VIRGULE
    if(sms_pos.charAt(count) == ',')
    {
      // SAUVE LA VALEUR CONVERTIE EN INT A LA POSITION p
      smspositions[p] = atoi(smspositions_str.c_str());
      //Serial.println(smspositions[p]);
      smspositions_str=""; // vide le string
      p++; // INCREMENTE p POUR QUE LA PROCHAINE POSITION SOIT ENREGISTREE A L INDEX SUIVANT  
    }
    else
    {
      smspositions_str.concat(sms_pos[count]); // UNE POSITION DANS smspositions_str, AVANT TANT QU'IL NE RENCONTRE 
//PAS UNE VIRGULE
    }
    
    count++;
    
    //Serial.print(F("Compare "));Serial.print(p);Serial.print(F(" with "));Serial.println(count_comma-1);
    
  }while(p < count_comma); // DES QUE p EST EGAL-1 A count_comma QUI EST IDENTIQUE A count_message, SORT DE LA BOUCLE
  
// JUSQU'ICI CA MARCHE TRES BIEN.

// A PARTIR D ICI CA BUG  

  for(int s=0; s < count_message; s++)
  {
    //Serial.println(smspositions[s]);
    if(s < 10) // CECI EST TEMORAIRE. CA ME PERMETS QUE DE LIRE LES 10 PREMIERS MESSAGE NON-LU
    {
      Serial.println(smspositions[s]);
// SI JE COMMENTE LA FUNCTION sms_read(), CA MARCHE TRES BIEN
// SI JE DECOMMENTE LA FONCTION sms_read(), CA MARCHE SAUF QUE LORSQU'IL ARRIVE A LA LECTURE DU DERNIER MESSAGE, QU IL AIT 5 OU 10 OU 15 MESSAGES NON-LU A LIRE. LE TERMINAL BLOQUE A LA LECTURE DU DERNIER MESSAGE
      sms_read(smspositions[s],sms_from_number,sms_date,sms_time,sms_text);
    }
  }
  
  Serial.println(F("End sms list"));
  //return smspositions;
}

Ce qui me rend fou, mais fou, c’est quand quand je tape, dans mon treminal

sms,r

la fonction sms_read() fonctionne parfaitement.

Mais quand je tape

sms,l

ma fonction

sms_read()

bloque le terminal, à la lecture du dernier message.

Mais pourquoi???
Es-ce que c’est parce l’appel de sms_read() se trouve deja dans la fonction sms_list()???

Je vous remercie pleinement si vous pouviez m’aider, parce que je passe des heures sans avancer.

PS: toutes les variables qui ne sont pas déclarer dans les codes présentés, sont déclarées avant le setup().
Si vous avez besoin de lire plus de code, faite le moi savoir.

J’espère que vous allez pouvoir m’aider, ca serait super cool!!

Milles milles Mercis

Je peux deja mettre le code de sendATcommand() et sms_read()

Voici ma fonction sms_read()

void sms_read(int pos_sms,char *sms_from_number, char *sms_date, char *sms_time, char *sms_text)
{
  // Definie une variable
  char cmds[12];
  // Defini la command
  sprintf(cmds,"AT+CMGR=%i,1",pos_sms);

  sendATcommand(cmds,"OK",2000,true,false,true,false); 
// commande, attend pour le OK, ln, retourne uniquementla réponse de la commande, debug

  splitString(supprimeCaractere(buffer_by_line[2],'"'),splitedString); // ICI, SUPPRIME LES ", ET MET LA LIGNE lu DANS UN ARRAY
  //splitString(buffer_by_line[2],splitedString);
  memset(sms_from_number,'\0',SMSFROMNUMBERSIZE);
  strncpy(sms_from_number,splitedString[1],SMSFROMNUMBERSIZE);
  
  memset(sms_date,'\0',SMSDATESIZE);
  strncpy(sms_date,splitedString[3],SMSDATESIZE);
  memset(sms_time,'\0',SMSTIMESIZE);
  strncpy(sms_time,splitedString[4],SMSTIMESIZE); 
  
  memset(sms_text,'\0',max_SMS_len);
  strncpy(sms_text,buffer_by_line[3],max_SMS_len);
  
  #ifdef DEBUG_SMS
    Serial.print(F("Info :")); Serial.print(buffer_by_line[0]); 
    if(strstr(splitedString[0],"REC UNREAD") != NULL)
    {
      Serial.print(F(" - "));Serial.println(F("UNREAD"));
    }
    else
    {
      Serial.println(F("\n"));
    }
    Serial.print(F("From :")); Serial.println(sms_from_number);
    Serial.print(F("Date :")); Serial.println(sms_date);
    Serial.print(F("Time :")); Serial.println(sms_time);
    Serial.print(F("Message :")); Serial.println(sms_text);
    Serial.println("\n");
  #endif
 
}

Cette fonctionne bien. Quoi, du moins quand je l’appelle dans d’autre cas, ca fonctionne. Donc je ne pense pas que cette fonction est la source du problème,. :slight_smile:

uint8_t sendATcommand(char* ATcommand, char* expected_answer1, unsigned int timeout, boolean ln, boolean getResponse, boolean debug_buff,boolean bufferBy_Line)
{ 
    uint8_t x=0, answer=0;
    unsigned long previous;

    memset(buffer, '\0', BUFFERSIZE);    // Initialize the string

    delay(100);

    while(Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    if(ln)
    {
      Serial1.println(ATcommand);    // Send the AT command 
    }
    else
    {
      Serial1.print(ATcommand);
    }

    //x = 0;
    previous = millis();

    // this loop waits for the answer
    do{
        if(Serial1.available() > 0){
          if(x < BUFFERSIZE-1) // Do not fill the buffer more the it size
          {
            buffer[x] = Serial1.read(); // response
            x++;
            // check if the desired answer is in the response of the module
            
            if(!debug_buff)
            {
              if (strstr(buffer, expected_answer1) != NULL)    
              { 
                 answer = 1;
              }
            }
            
          }
        }
        // Waits for the asnwer with time out
    }
    
    while((answer == 0) && ((millis() - previous) < timeout));   

    if(debug_buff){
    
      if (strstr(buffer, expected_answer1) != NULL)    
      {
        answer = 1;
      }
      
      Serial.println(F("\n*** RESPONSE ***"));
      Serial.println(buffer);
      Serial.println(F("****************\n"));
    }
    
    if(bufferBy_Line || getResponse)
    {
      bufferByLine(buffer,buffer_by_line);
    }
    
    if(getResponse)
    {
      sprintf(buffer,buffer_by_line[2]);
    }
    else
    {
      //strcpy(buffer,response);
    }
    delay(100);
    return answer;
}

Merciiiii

J’avais le même besoin hier .
Voici ce que j’ai trouvé sur le net.

int CountChar(String input, char c )
{
  int retval = 0;
  for (int i = 0; i < input.length()+1; i ++)
  if (c == input [i])
  retval ++;
  return retval;
}

Utilisation
String machaine = “A,B,C”;
int nombredevirgule = CountChar(machaine, ‘,’);

Une autre fonction simpa est la suivante .
Elle permet de récupérer la valeur xème d’une chaine :

String getValueFromArray(String data, char separator, int index)
{
  int found = 0;
  int strIndex[] = {0, -1};
  int maxIndex = data.length()-1;

  for(int i=0; i<=maxIndex && found<=index; i++){
    if(data.charAt(i)==separator || i==maxIndex){
        found++;
        strIndex[0] = strIndex[1]+1;
        strIndex[1] = (i == maxIndex) ? i+1 : i;
    }
  }  
  return found>index ? data.substring(strIndex[0], strIndex[1]) : "" ;
}

Utilisation:
String machaine =“A,B,C”;
int nb = getValueFromArray(machaine, ‘,’, 0).toInt();

nb doit être ici = à A