Petit problème avec un switch et un char

Bonjour,

J’ai créé une fonction avec laquelle je peux extraire une partie d’un texte en fonction du séparator.

Au début j’utilisais le séparator ‘,’ (la virgule)

Maintenant j’aimerais chosir le séparator en la passant en parametre dans ma fonction.
Voici la fonction

void SIM908::get_value(char * chaine, byte index, char * separator, char * get_value)
{
  // Get the value from a char delimited with comma
  // 123,rftzg,4568
  // get_value(1), will return rftzg

  // char chaine[]= {block0,block1,block2,block3}

  // Initiate the 
  byte ind = 0; // Position of the block of data into the chaine
  byte x = 0;   // index of val. Value to retunr.
  byte ic = 0;  // Index Chaine
  bool flag = false;  // True when it's part of block we need to extract
  

  // If we need the first block (block0), flag must be true
  if(index == 0)
  { 
    flag = true;
  }

  // In my comment, take in concideration that index is egal to 0. We need to print the first block : 'block0'
  do // Go trough chaine, one by one
  {
    //Serial.println(chaine[ic]);
    switch(chaine[ic]){
      case ',':                 // When it read a comma, increment ind. Ind will no be egal to index and then val will not take new value. 
        ind++;                  // See default:
        ic++;
        continue;               // return to the begin of 'do' loop and check next position of chaine
      
      default:
        if(ind == index)        // if ind is egal to index. Index is the block we decide to have printed
        {
          get_val[x] = chaine[ic];  // Store the desired value in val  
         // Serial.print(F("Def")); Serial.println(val[x]);
          x++;
        }
    }
    
    ic++;                       // Go to next position of chaine
    //Serial.print(F("co")); Serial.println(co);

  }while( ic <= strlen(chaine)); // As long as ic is < than the amount tof caracter in chaine, and then leave the do loop
  get_val[x]='\0';  // Close val with \0
  
  //Serial.print(F("sr:")); Serial.println(get_val);
  //return get_val;
}

Mon problème est dans le switch et particulirement sans le case

...
 switch(chaine[ic]){
      case ',': 
....

Je dois donc remplacer la virgule par la vatiable ‘separator’

et quand je fais ca

...
 switch(chaine[ic]){
      case separator: 
....

et ben ca bug. Quand je compile, j’ai ce message:

error: ‘separator’ cannot appear in a constant-expression
case separator:

Comment puis-je utiliser la variable dans un case??

Merci!!

Pas possible, car switch/case demandent des valeurs connues à la compilation.

Pourquoi n'utilises-tu pas strtok() ?

Yep!

Ce n'est pas strtok_r() ???

Par exemple :

void filldata(char *buffer) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) {     // delimiter is the semicolon
    char *q = str;
    TRAME[i] = q;
    i++;
  }
}

Je remplis le tableau TRAME[] des caractères précedent le ";"

La fonction complète pour info :

/*
############################################################################
SECTION : LOOK AND MANAGE INCOMING SERIAL MESSAGE
############################################################################
The getSerialString function looks for a valid message, with a header and a foot.
if message is valid, it is split to each TRAME spaces in filldata function.
Every splited data begins with a unique identifier flag, which will build valid 
functions and variables depending on position. This is my choice!
For exemple, the 'T' flag means that data is concerning clock update.
More things could be combined.
############################################################################
*/
void checkMsg() {
  if (getSerialString()) {                                                  // On verifie que la trame soit complete
    filldata(buffer);                                                       // On remplit la structure des donnees
    checkdata();                                                            // On renseigne les variables modifiees
  }
}

boolean getSerialString() {
  int dataBufferIndex = 0;
  boolean storebuffer = false;
  delay(20);
  if(Serial.available() > 1){
        char incoming = Serial.read();
        if(incoming==STARTBIT){
            dataBufferIndex = 0;                                            //Initialize our dataBufferIndex variable
            storebuffer = true;
        }
        if(storebuffer){
          while(Serial.available()){
            char incoming = Serial.read();
            delay(50);
            if(dataBufferIndex == BUFFERSIZE){dataBufferIndex = 0; break; }
            if(incoming == STOPBIT) {buffer[dataBufferIndex] = 0; dataBufferIndex = 0; storebuffer = false; return true; }
            else { buffer[dataBufferIndex++] = incoming; }
          }
        }
  }
  return false;
}

void filldata(char *buffer) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) {                             // delimiter is the semicolon
    char *q = str;
    TRAME[i] = q;
    i++;
  }
}

J'utilise ensuite la fonction strcmp() pour comparer mon tableau de valeurs découpées selon le séparateur à autre chose :

if (strcmp(TRAME[0], "QUELQUECHOSE") == 0) { action }

@+

Zoroastre.