aide sur la prog c

Bonsoir,

Je souhaiterais un coup de mains sur un bout de code de ma création, pour commencer, je ne suis pas informaticien, mais uniquement bidouilleur... et ça se voit...

void verifie_encapsulation()
{
// module servant à séparer les informations à envoyer pour commander une action
// le "mot" global est dans "recept" et il doit comporter "[" + adresse interrupteur + "," + groupe? (0/1) + "," + ON/OFF (0/1) + "," + recipient + "]"

char add_inter[10];                              // adresse de l'interrupteur
char groupe[1]      ;                              // commande de groupe ?
char on_off[1]      ;                              // allumage ou extinction
char recip[3] ;                              // récipient
int boucle = 0      ;                              // indice de boucle
int en_cours = 0;                                    // valeur du caractère en cours


while (boucle <50)
      {

            if (recept[boucle] == 91)            // si la valeur de l'octet = "["
            { 
            boucle +=1 ;
            int boucle2 = 0 ;
            
            while (recept[boucle] != 44)            //tant que pas réception d'une ","
                  {
                  add_inter[0+boucle2] = recept[boucle] ;      //met la valeur de l'octet trouvé dans "add_inter"
                  boucle += 1 ;
                  boucle2 += 1 ;
                  }
            add_inter[0+boucle2]='\0';

            boucle +=1 ;
            
            groupe[0] = recept[boucle];
                groupe[1]='\0';

            
            boucle +=1 ;

            if (recept[boucle] != 44)
                  {
                  Serial.println ("erreur dans l'envoi1");
                        recept[0] = '\0';
                  return;
                  }
            
            boucle += 1;
            

            on_off[0] = recept[boucle];
            on_off[1] = '\0';
            

            boucle += 1;
                        
            if (recept[boucle] != 44)
                  {
                  Serial.println ("erreur dans l'envoi");
                        recept[0] = '\0';
                  return;
                  }
            
            boucle += 1;

            boucle2 = 0;
            while (recept[boucle] != 93)            //tant que pas réception d'une "]"
                  {
                  recip[0+boucle2] = recept[boucle] ;      //met la valeur de l'octet trouvé dans "recip"
                  boucle += 1 ;
                  boucle2 += 1 ;
                  }
                recip[0+boucle2] = '\0';            

            Serial.print ("adresse inter : ");
            Serial.println (add_inter);
            Serial.print ("groupe : ");
            Serial.println (groupe);
            Serial.print ("on_off : ");
            Serial.println (on_off);
            Serial.print ("recipient : ");
            Serial.println (recip);
                recept[0] = '\0';
                return;
            
            }
      boucle += 1;
      }


}

en résumé, je reçois une info venant de mon PC sous une forme indiquée en REM ci dessus.
Mon problème réside dans les char... j'ai beau lire une tonne de docs, je n'arrive pas à élucider le mistère du "*" indiquant l'adresse du char ou sa valeur.

Dans le cas ci dessus, mes informations "groupe" et "on-off" sont fausses au moment où elles arrivent au serial.print, alors qu'elles sont bonnes au moment de la ligne de chargement de valeur.
Si j'écris par contre : Serial.print (*groupe), je retrouve la bonne valeur, mais je me doute que la formulation n'est pas bonne...

Alors si un "sachant" pouvait me filer un coup de mains....

Merci d'avance,

je n'arrive pas à élucider le mistère du "*" indiquant l'adresse du char ou sa valeur

Dans ton cas tu adresses tes tableaux avec un index donc tu n'as pas besoin de manipuler de pointeur

Dans le cas ci dessus, mes informations "groupe" et "on-off" sont fausses au moment où elles arrivent au serial.print,

c'est à dire?
Donne un exemple de ce que tu reçois.

bonjour, et merci d'avoir répondu,

les symptomes :
j'envoi par la console une info du style : [123456,1,0,12] (c'est un message type d'un inter homeeasy).

Lorsque je met un Serial.print(groupe) après la ligne :

groupe[0] = recept[boucle];
groupe[1]='\0';

la réponse donne "1" - bon résultat

Mais au serial.print(groupe) de fin de programme, la réponse à la même question donne "1012",
C'est à dire qu'il a continuer à incrémenter "groupe"...
Par contre, si je lui demande serial.print(*groupe), là il me donne "1"
D'ou mon interrogation par rapport aux pointeurs et aux indexes...

Là, je m'arrache le peu de cheveux qu'il me reste... Ayez pitier de ma calvitie naissante !!! :cry:

:wink: ;D :wink:

@+

char add_inter[10]; // adresse de l'interrupteur
char groupe[1] ; // commande de groupe ?
char on_off[1] ; // allumage ou extinction
char recip[3] ; // récipient
int boucle = 0 ; // indice de boucle

Je viens de voir le problème.
C'est la définition de tes tableaux qui pose problème. Si on prend groupe par exemple (mais le problème est le même pour on_off). Tu définis cette variable comme un tableau de 1 caractère (groupe[1]). Et donc il est trop petit pour contenir la valeur + le terminateur (\0). il faudrait définir groupe comme cela

char groupe[2]      ;                              // commande de groupe ?

Pour les chaines de caractères, il faut toujours faire +1 sur la taille à cause du terminateur.
En fait dans ton code

groupe[0] = recept[boucle];
groupe[1]='\0';

tu places bien un terminateur à ta chaine c'est pourquoi lorsque tu la fais afficher aussitôt après le printf est bon. Mais le terminateur est écrasé par la suite par une autre variable.
Il faut bien voir que l'éditeur de lien après la compilation alloue des emplacements en mémoire aux variables en fonction de leur taille. Cette taille est déterminée par le type de la variable et dans le cas des tableaux par le nombre d'éléments. Les variables sont placées en mémoire les unes derrière les autres. ce qui explique que ton terminateur soit écrasé par la suite.

Youp !

Merci, je va essayer dès ce soir, :smiley:

à bien y réfléchir, et si j'ai bien compris ce que tu indiques,
J'ai du confondre la déclaration "char groupe[1]" qui ouvre un tableau à 1 caractère
et groupe[1]='\0' qui est déjà le deuxième caractère...

j'adore le C !!!!! (c'est du deuxième degré ! :wink: )

Merci encore !!!

J'ai du confondre la déclaration "char groupe[1]" qui ouvre un tableau à 1 caractère
et groupe[1]='\0' qui est déjà le deuxième caractère...

Dans la déclaration on spécifie la longueur du tableau. Mais quand on l'utilise l'index part de 0 d'où l'écart de 1.