comparer deux strings !?!

Bonjour, j'envoie par VirtualWire.h le string "Arduino" via deux émetteurs/récepteurs RF et leurs Nano associés et je n'arrive pas à décoder la réception.
J'envoie "Arduino" de l'émetteur et je reçois bien "Arduino" dans le récepteur mais seulement en Serial.print; impossible de faire des tests dessus: problème de string, pointeur étoile string et int, je ne m'en sors pas.
Je voudrais juste faire le test comme quoi je reçois bien le string envoyé: en l’occurrence: "Arduino" et faire ensuite ce qu'il faut faire...

Comme çà:

/*****************************************************************
 * On envoie un nombre entier différent selon le bouton appuyé.
 * Boutons reliées aux entrées 2, 3 et 4.
 * Sketch de l'émetteur (branché à la pin 12, par défaut).
 * http://electroniqueamateur.blogspot.com/2014/01/modules-rf-433-mhz-virtualwire-et.html
 *****************************************************************/


#include <VirtualWire.h> // librairie VirtualWire

#include "define.h"    // définitions relatives au programme

int Nombre;

char Message[VW_MAX_MESSAGE_LEN] = "Arduino"; 

//const char *msg = "Arduino les bains"; // Tableau qui contient notre message
//char *msg = "Arduino"; // Tableau qui contient notre message

void setup()
{
  vw_setup(2000);        // Bits par seconde

  pinMode(bouton1, INPUT); 
  digitalWrite(bouton1, HIGH);  // pull up interne
  pinMode(bouton2, INPUT);
  digitalWrite(bouton2, HIGH);
  pinMode(bouton3, INPUT); 
  digitalWrite(bouton3, HIGH);    

  pinMode(test, OUTPUT);
  
  #ifdef ServerDEBUG
  Serial.begin(9600);       // for debugging
  #endif
  
}

void loop()
{  

  envoie ();

  delay(200); 
 

}

void envoie  ()  {

 // Nombre = 255;
  
  // convertion de l'int "Nombre" en tableau de char "Message"
  //itoa(Nombre,Message,10);  // 10 car décimal
  
   vw_send((uint8_t *)Message, strlen(Message));
   vw_wait_tx(); // Wait until the whole message is gone
     

  #ifdef ServerDEBUG
  Serial.println("Le message envoyé est: ");
  //Serial.println(Message);
  #endif
  
  int i;
  int lenght = strlen(Message);
  
            for (i = 0; i < lenght; i++)
            {               
              Serial.print(Message[i]);
            }
              Serial.println();

}

j'émets comme Emmett ...!
et je reçois comme açe:

/************************************************************** 
 * Allume une LED différente selon le message reçu.
 * LEDs reliées aux entrées 2,3 et 4.
 * Récepteur 433 MHz branché à l'entrée 11.
 * http://electroniqueamateur.blogspot.com/2014/01/modules-rf-433-mhz-virtualwire-et.html

 ***************************************************************/

#include <VirtualWire.h>

#include "define.h"    // définitions relatives au programme



int Nombre;

char Message[VW_MAX_MESSAGE_LEN];

char* mystring;

void setup() {     
  
  #ifdef ServerDEBUG
  Serial.begin(9600);
  Serial.println("initialisation serial at 9600 bps");
  #endif
  
   // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  
  pinMode(TEST, OUTPUT);
  digitalWrite (TEST,LOW);
  
  pinMode(RECEPT, OUTPUT);
  digitalWrite (RECEPT,LOW);

  vw_setup(2000);   // Bits par seconde   

  vw_rx_start();       

}

void loop(){
  uint8_t buf[VW_MAX_MESSAGE_LEN];
  uint8_t buflen = VW_MAX_MESSAGE_LEN;
 
   if (vw_wait_rx_max(200))  //  si un message est reçu dans les 200 ms qui viennent
   { 
          digitalWrite (TEST,LOW);  // extinction de la LED test

          if (vw_get_message(buf, &buflen)) 
          {  
            int i;
        
            for (i = 0; i < buflen; i++)
            {               
              Message[i] = char(buf[i]);
              #ifdef ServerDEBUG
              Serial.print(Message[i]);
              #endif
            }
            
            
            mystring = Message;
            
            //Serial.println(Message[buflen-2]);
            #ifdef ServerDEBUG
            Serial.println();
            Serial.print("Message complet = ");
            Serial.println(Message);
            #endif
            
            #ifdef ServerDEBUG
            Serial.print("Message complet du string= ");
            Serial.println(mystring);
            #endif
            
            

            decodage ();    // décode le "Message"

        
        
            //Message[buflen] = '\0';
        
            // Conversion du tableau de chars en int:
            Nombre = atoi(Message);
        
            if (Nombre == 1){
              digitalWrite (LED1,HIGH);
              digitalWrite(13, HIGH);   // turn the LED on
            }
            else if (Nombre == 2){
              digitalWrite (LED2,HIGH);
              digitalWrite(13, HIGH);   // turn the LED on
            }
            else if (Nombre == 3){
              digitalWrite (LED3,HIGH);
              digitalWrite(13, HIGH);   // turn the LED on
            }
            else if (Nombre == 4){
              digitalWrite (LED1,LOW);
              digitalWrite (LED2,LOW);
              digitalWrite (LED3,LOW);
              digitalWrite(13, LOW);   // turn the LED off
              //Serial.println(buf[VW_MAX_MESSAGE_LEN]);
            }
        
          }  /// fin de if (vw_get_message(buf, &buflen))
   }  /// fin de if (vw_wait_rx_max(200))
   //if (vw_wait_rx_max(1000) == 0)  //  si un message n'est pas reçu dans les 1000 ms qui viennent
   else if (vw_wait_rx_max(400) == 0)  //  si un message n'est pas reçu dans les 1000 ms qui viennent
   {
          
     #ifdef ServerDEBUG
     Serial.println("Message recu: rien du tout");
     #endif
     digitalWrite (TEST,HIGH);  // signalement de perte de réception par allumage de la LED test
   }
        
}    // fin de loop


/////  fonction decodage qui "analyse" le code reçu
void decodage  (void)  {
  if (mystring == 'Arduino')  {
    digitalWrite(RECEPT, HIGH);
  }
    
}    // fin de decodage ()

En gros, comment faire pour faire pour tester qu'il reçois bien "Arduino" et faire ce qui s'en suit mais pas seulement que l'afficher.com ?
==> problèmes de types/genres int/string/tableaux de chars/pointeurs sur tableaux de chars etc....
Quelle serait l'astuce ? lien ? Réponse directe !

Soit utiliser l'objets String défini par les librairies Arduino et qui surcharge l'opérateur == (et d'autres)
Soit utiliser la librairies C standard string.h là ou là

Merci beaucoup, je ne me souvenais plus de la fonction strcmp ou je ne la connaissais plus; depuis l'temps.
J'ai réussi à faire exactement c'que j'voulais grâce à ce lien: transmettre et comparer un Mot

Par contre, juste une dernière question: les espaces n'ont pas l'air d'être appréciés; il croit peut-être que c'est la fin de la chaîne ?
Je ne peux pas transmettre de phrases ?
ex: "Arduino les Bains" ne fonctionne pas mais "ArduinolesBains" fonctionne !

Bonjour,

Il n'y a aucun problème pour transmettre des strings avec des espaces. Ces derniers sont des caractères comme les autres.

Effectivement; "Arduino les bains" est différent de "Arduino les Bains" !!!

tu as des versions de strcmp qui sont insensibles à la casse (stricmp & co)

Bonsoir, je reviens vers vous puisque j'ai un petit souci encore par rapport aux espaces dans les 'strings' que j'envoie: tout fonctionne correctement quand je n'envoie qu'un seul mot mais dès qu'il y a un espace: une phrase, ça ne fonctionne plus; l'égalité du 'string' n'est plus vérifiée!
Les codes en test:

émetteur:

/*****************************************************************
 * On envoie un nombre entier différent selon le bouton appuyé.
 * Boutons reliées aux entrées 2, 3 et 4.
 * Sketch de l'émetteur (branché à la pin 12, par défaut).
 * http://electroniqueamateur.blogspot.com/2014/01/modules-rf-433-mhz-virtualwire-et.html
 *****************************************************************/

/**************************************************************/
/*                                                            */
/*  protocol de transmission des trames :                     */
/*  protocol = 1 ==> en-tête                                  */
/*  protocol = 2 ==> identifiant récepteur                    */
/*  protocol = 3 ==> commande                                 */
/*                                                            */
/**************************************************************/

#include <VirtualWire.h> // librairie VirtualWire

#include "define.h"    // définitions relatives au programme

int protocol = 1;    // indique où en est le protocol

int Nombre;

//char Message[VW_MAX_MESSAGE_LEN] = "Arduino";
char entete[VW_MAX_MESSAGE_LEN] = "Arduino";
char identifiant[VW_MAX_MESSAGE_LEN] = "Hangar";

char commande[VW_MAX_MESSAGE_LEN];  // 'string' de la commande
                                    //  envoyée à exécuter

void setup()
{
  vw_setup(2000);        // Bits par seconde

  pinMode(bouton1, INPUT); 
  digitalWrite(bouton1, HIGH);  // pull up interne
  pinMode(bouton2, INPUT);
  digitalWrite(bouton2, HIGH);
  pinMode(bouton3, INPUT); 
  digitalWrite(bouton3, HIGH);    

  pinMode(test, OUTPUT);
  
  #ifdef ServerDEBUG
  Serial.begin(9600);       // for debugging
  #endif
  
}

void loop()
{  

  envoie (entete);

  delay(200); 
  
  envoie (identifiant);

  delay(200); 
 
  char commande[VW_MAX_MESSAGE_LEN] = "allume led orange";
    
  envoie (commande);

  delay(200); 
 

}

void envoie  (char* message)  {
  
///   vw_send((uint8_t *)Message, strlen(Message));
   vw_send((uint8_t *)message, strlen(message));
   vw_wait_tx(); // Wait until the whole message is gone
  
  int i;
  int lenght = strlen(message);
  
            for (i = 0; i < lenght; i++)
            {               
              Serial.print(message[i]);
            }
              Serial.println();

}

et le récepteur:

/************************************************************** 
 * Allume une LED différente selon le message reçu.
 * LEDs reliées aux entrées 2,3 et 4.
 * Récepteur 433 MHz branché à l'entrée 11.
 * http://electroniqueamateur.blogspot.com/2014/01/modules-rf-433-mhz-virtualwire-et.html

 ***************************************************************/
 /*                                                            */
 /*  protocol de transmission des trames :                     */
 /*  protocol = 1 ==> en-tête reçue                            */
 /*  protocol = 2 ==> identifiant récepteur reçu               */
 /*  protocol = 3 ==> commande reçue                           */
 /*                                                            */
 /**************************************************************/

#include <VirtualWire.h>

#include "define.h"    // définitions relatives au programme


int protocol = 1;    // indique où en est le protocol

uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;

char entete[VW_MAX_MESSAGE_LEN] = "Arduino";
char identifiant[VW_MAX_MESSAGE_LEN] = "Hangar";


void setup() {     
  
  #ifdef ServerDEBUG
  Serial.begin(9600);
  Serial.println("initialisation serial at 9600 bps");
  #endif
  
   // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  
  pinMode(TEST, OUTPUT);
  digitalWrite (TEST,LOW);
  
  pinMode(RECEPT, OUTPUT);
  digitalWrite (RECEPT,LOW);

  vw_setup(2000);   // Bits par seconde   

  vw_rx_start();       

}

void loop(){
//  uint8_t buf[VW_MAX_MESSAGE_LEN];
//  uint8_t buflen = VW_MAX_MESSAGE_LEN;
 
    recept ();  // réception du message via le module RF
    
    //decodage (buf);    // décode le "Message"
            
    dectrame (buf);    // décode la trame
        
}    // fin de loop

///// fonction de réception du message reçu par le récepteur RF 433 MHz
void recept (void)  {
  
  
     if (vw_wait_rx_max(200))  //  si un message est reçu dans les 200 ms qui viennent
   { 
          digitalWrite (TEST,LOW);  // extinction de la LED test de réception signal

          if (vw_get_message(buf, &buflen)) 
          {  
            int i;
        
            for (i = 0; i < buflen; i++)
            {               
              buf[i] = char(buf[i]);
            }
                      
            buf[buflen] = '\0';


        
          }  /// fin de if (vw_get_message(buf, &buflen))
   }  /// fin de if (vw_wait_rx_max(200))
 
   else if (vw_wait_rx_max(400) == 0)  //  si un message n'est pas reçu dans les 1000 ms qui viennent
   {
          
     #ifdef ServerDEBUG
     Serial.println("Message recu: rien du tout");
     #endif
     digitalWrite (TEST,HIGH);  // signalement de perte de réception par allumage de la LED test
   }
   
}    // fin de fonction recept


/////  fonction decodage qui "analyse" le code reçu
void decodage  (uint8_t * message)  {
//  if (strcmp("Arduino",(char*) buf) == 0)  {
//  if (strcmp(entete,(char*) buf) == 0)  {    // égal 0 si comparaison vraie
  if (strcmp(entete,(char*) message) == 0)  {    // égal 0 si comparaison vraie
     #ifdef ServerDEBUG
     Serial.println("Le mot 'Arduino' a bien été reçu : ");
     Serial.println((char*) buf);
     #endif
     digitalWrite(RECEPT, HIGH);
     delay(2000);
     digitalWrite (RECEPT,LOW);
     delay(2000);

 
 
 
 
  }  else {
    Serial.println("La comparaison n'est pas vérifiée");
  }
     
  }  // fin de decodage
  
  
/////  fonction de décodage de la trame
void dectrame  (uint8_t * message)  {
    switch (protocol) {
        case 1:    // vérification de l'en-tête
            if (strcmp(entete,(char*) message) == 0)  {    // égal 0 si comparaison vraie
             #ifdef ServerDEBUG
             Serial.println("Le mot 'Arduino' a bien été reçu : ");
             Serial.println((char*) buf);
             Serial.println("entete reçue");
             #endif
            protocol++;
            }  else  {
              Serial.println("En-tête non reconnue");
            }
            break;
        case 2:    // vérification de l'identifiant
        
         //    digitalWrite(RECEPT, HIGH);
         //    delay(2000);
         //    digitalWrite (RECEPT,LOW);
         //    delay(2000);
             
            Serial.println("verifying login");
            protocol++;
            break;
        case 3:    // exécution de la commande
            Serial.println("login ok");
            /// ici j'exécute la commande envoyée...
            Serial.println((char*) buf);
            
            if (strcmp("allume led orange",(char*) message) == 0)  {    // égal 0 si comparaison vraie
             #ifdef ServerDEBUG
             Serial.println("Allumage de la led orange");
             #endif
             
             digitalWrite (LED3,HIGH);
            
            protocol = 1;    // prêt à recevoir une autre trame
            }
            break;

        default:
            Serial.print("Dispositif inconnu: 'protocol' = ");
            Serial.println(protocol);
            break;
          }      /// fin de switch
    }  // fin de dectrame

Et j'ai bien vérifié à l'émetteur, j'envoie bien la bonne trame: "Arduino", "Hangar", "allume led orange", "Arduino", "Hangar", "allume led orange", "Arduino", "Hangar", "allume led orange", "Arduino", "Hangar", "allume led orange", "Arduino", "Hangar", "allume led orange", "Arduino", "Hangar", "allume led orange"

Mais je ne reçois que: "Arduino", "Hangar", "allume" !!!
Donc le test suivant exécutant la commande appropriée ne peut pas être vérifiée puisque j'attends; "allume led orange", et non pas "allume" tout court.
Qu'ai-je commis comme erreur ?

Bonjour,

Les espaces sont des caractères comme les autres, il n'y a pas de problème pour les transmettre et les recevoir.
Le problème dans ton programme de réception est que tu n'initialises pas buflen avant réception -> tu ne peux pas recevoir un message plus long que le précédent.
Il faut faire

   buflen=VW_MAX_MESSAGE_LEN;  // !! il faut initialiser buflen
   if (vw_get_message(buf, &buflen))
   {

Ok, merci beaucoup, c'est vrai que ça paraît logique maintenant de savoir quelle est la longueur de la chaîne avant CHAQUE réception...
Allez, bon dimanche.