Mise au point reconnaissance vocale Geeetech


Bonjour à tous.

Je vous remercie déjà pour l'attention et l'aide que vous pourrez m'apporter pour ce projet qui me tient à coeur et qui m'occuper depuis plusieurs mois déjà.. La passion ne compte pas ses heures....
J'ai fabriqué une armure d'Ironman MK85 à ma taille. J'ai finis toutes la parties carrosserie. J'avais déjà fais un programme, tout embarqué dans le casque, qui tournait sur Arduino Nano mais sans reconnaissance vocale et pour gérer les fonctions du casque, ouverture/fermeture par sensor et gyro 3axes, un buzzer pour quelques sons, tmp36 pour la gestion de la température interne etc. On peut d'ailleur encore voire les bribes de l'ancien programme dans le nouveau mais je vais récupérer toutes les anciennes fonctions. (Du coups j'espère que mon programme sera assez lisible).
Maintenant que j'ai fais l'armure entière il y a plein d'autres gadjets en plus et depuis 2 semaines je m'attaque à la partie programmation des divers gadjets dont elle est équipée. (laissant un peu de côté la partie hydrogène..)
Pour me permettre de commander les divers fonctions de l'armure j'ai opté pour une reconnaissance vocale.
Pour ce faire j'ai acheteé un module de reconnaissance vocale Geeetech, il peut enregistrer 15 ordres divisé en 3 groupes de 5.
Après pas mal de recherches et de documentation j'ai écris la trame principale (les activations des divers fonctions découlant des commandes vocales ne sont pas encore écritent mais ne me poseront pas de problèmes du moment que la trame principale sera opérationnelle). Ayant besoins d'une dizaine de fonctions, pour commencer, je dois accèder au groupe d'ordre 1: (0x21), ce qui ne me pose pas de problème. En revanche pour les ordres du groupe 2 : (0x22) j'ai beaucoups plus de soucis.

Le résultat n'est pas aléatoire mais je n'arrive pas suffisamment à définir la logique de fonctionnement actuelle de mon programme pour me permettre de résoudre ce mon challenge.

Je viens donc humblement demander votre aide :pray:





/////////////////////////////////////////////////////
//////////   rappel connectique   //////////////
////////////////////////////////////////////////////
/*
  ARDUINO ||  COMPOSANTS MEGA 2560
  D19 TX  ||  RX module vocal
  D18 RX  ||  TX module vocal
  D2      ||
  D3      ||
  D4      ||
  D5      ||  + du Buzzer
  D6      ||
  D7      ||
  D8      ||
  D9      ||
  D10    ||
  D11    ||
  D12    ||
  D13    ||
  D46    ||  + du Haut Parleur
  D50    ||  MISO lecteur SD
  D51    ||  MOSI lecteur SD
  D52    ||  SCK lecteur SD
  D53    ||  CS lecteur SD
  5V       ||  lecteur SD + module vocal + relais + relais
  GND   ||  lecteur SD + - du HP + module vocal + cube + relais + relais + ecritaux
*/




//////////////////////////////////////////////////////////////////////////////////
/////  Bibliothèque des sons disponibles  ///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
//// S_CONNECTION   S_DISCONNECTION S_BUTTON_PUSHED  //
//// S_MODE1        S_MODE2         S_MODE3  //////////////////////////
//// S_SURPRISE     S_OHOOH         S_OHOOH2 ///////////////////////
//// S_CUDDLY       S_SLEEPING      S_HAPPY  //////////////////////////
//// S_SUPER_HAPPY  S_HAPPY_SHORT   S_SAD    ////////////////////
//// S_CONFUSED     S_FART1         S_FART2  ///////////////////////////
//// S_FART3        S_JUMP 20                ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////




///////////////////////////////////////////////////////
////////////////////  Librairies  /////////////////////
///////////////////////////////////////////////////////
#include <pcmConfig.h>            // Library lecture Wav
#include <pcmRF.h>                // Library lecture Wav
#include <TMRpcm.h>               // Library lecture Wav
#include <Servo.h>                // Librairie Servo
#include <SD.h>                   // Library Carte SD
#define SD_Pin 53                 //define CS pin ATTENTION SI AUTRE BOARD!!
#include <CuteBuzzerSounds.h>     //librairie buzzer
#include <Sounds.h>               //librairie buzzer      
#include <TMP36.h>                // Librairie TMP36
#include <Wire.h>                 // Must include Wire library for I2C
#include <Servo.h>                // Librairie Servo




/////////////////////////////////////////////////////////////
///////////////  variables des sorties  /////////////////
////////////////////////////////////////////////////////////

Servo servoG;               // créer objet servo gauche
Servo servoD;               // créer objet servo droit

TMRpcm speaker;             //objet "speaker

int temoin = 13;            //led arduino uno pour nano = 6  et 13 our Mega!!

byte mess = 0;              //variable de stockage du message

int jarvis = 0;
int voix;                   //voix de Jarvis
int musique;                 //musique à disposition

bool allume;
bool eteind;

int etatMasque = 0;         //stock l'état du masck  0=masque fermé / 1=masque ouvert
int etatLed = 0;            //stock l'état du rétroéclairage 0=éteind / 1=allumé
int etaTech = 0;            //stock l'état d'appel du second groupe d'ordres
int etaTurbine = 0;         //stock l'état de la turbine
int etatMusique = 0;        //stock l'état de la lecture de la musique

const int sensor = 4;         // sensor créé sur pin 4
int lastState = LOW;          // etat précédent du sensor
int currentState;                   // la lecture actuelle du sensor
const int relais = 2;             // relais allumage yeux créé sur pin 2
const int ledChauffe = 3;   // led contrôle surchauffe créée sur pin 3





void setup() {
 
 Serial.begin(9600);      //initialise le miniteur série


  /////////////////////////////////////////////////////////////////
  ///////////////// déclaration speaker /////////////////////
  ////////////////////////////////////////////////////////////////
  speaker.speakerPin = 46;    //définnie le pin du speaker. 

  if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
    return;
  }
  speaker.setVolume(5);           //volume level : 0 to 7


  ///////////////////////////////////////////////////
  ///////////  déclaration sortie ///////////////
  //////////////////////////////////////////////////

  pinMode(temoin, OUTPUT);

  //////////////////////////////////////////////////
  ///////////// sortie éteinte //////////////////
  /////////////////////////////////////////////////

  digitalWrite(temoin, LOW);


  /////////////////////////////////////////////////////
  ////////////// module micro ///////////////////
  ////////////////////////////////////////////////////

  Serial.write(0xAA);
  Serial.write(0x00);//attente
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x37);//Compact mode
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x00);//attente
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x21);//importe groupe 1

}



void loop()
{

  while (Serial.available())
  {
    mess = Serial.read();  //recoit le message et le stock dans la variable mess



    ////////////////////////////////////////////////
    //////////////// reveille /////////////////////
    ///////////////////////////////////////////////

    if ((jarvis == 0) && (mess == 0x11)) //jarvis
    {

      Serial.println("Jarvis");

      voix = random(1, 8);                       //random de 1 à 7
      delay (500);

      if (voix == 1) {
        speaker.play("1.wav");
      }
      if (voix == 2) {
        speaker.play("2.wav");
      }
      if (voix == 3) {
        speaker.play("3.wav");
      }
      if (voix == 4) {
        speaker.play("4.wav");
      }
      if (voix == 5) {
        speaker.play("5.wav");
      }
      if (voix == 6) {
        speaker.play("6.wav");
      }
      if (voix == 7) {
        speaker.play("7.wav");
      }

    }

    jarvis = 1;
    digitalWrite(temoin, HIGH);


  }


  //////////////////////////////////////////////////
  ///////////////// Ordres //////////////////////
  /////////////////////////////////////////////////

  if (jarvis == 1) {
    if ((mess == 0x12) && (etatMasque == 0)) //ouverture masque
    {
      jarvis = 0;
      etatMasque = 1;
      Serial.println("Ouvre masque");

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;                  //variable mess remise à zero

    }


    if ((mess == 0x12) && (etatMasque == 1)) //ferme masque
    {
      jarvis = 0;
      etatMasque = 0;
      Serial.println("Ferme masque");

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;

    }



    if ((mess == 0x15) && (etatMusique == 0)) //passe de la la musique aléatoirement
    {
      jarvis = 0;
      etatMusique = 1;

      Serial.println("Musique ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if ((mess == 0x15) && (etatMusique == 1)) //éteind la musique
    {
      jarvis = 0;
      etatMusique = 0;

      Serial.println("Musique OFF");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);                     // appel le 1er groupe d'ordre
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Allumage
    {
      jarvis = 3;
      allume = 1;
      eteind = 0;
      Serial.println("Allumes");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x22);                // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x14) //Extinction
    {
      jarvis = 3;
      eteind = 1;
      allume = 0;
      Serial.println("Eteinds");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x22);               // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
  }

  //////////////////////////////////////////////////
  //////////////// allumage /////////////////////
  //////////////////////////////////////////////////

  if ((jarvis == 3) && (allume == 1)) {


    if (mess == 0x11) //Led allumées
    {
      jarvis = 0;

      Serial.println("Led ON");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x12) //Smog actif
    {

      jarvis = 0;

      Serial.println("Smog ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Turbine en rotation
    {

      jarvis = 0;

      Serial.println("Turbo ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14) //Flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo start");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15) //Enclenche la demo
    {

      jarvis = 0;

      Serial.println("Demo active");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }
  ///////////////////////////////////////////////
  //////////////// extinction ///////////////////
  ///////////////////////////////////////////////
  if ((jarvis == 3) && (eteind == 1)) {

    if (mess == 0x11)//Extinction LED
    {

      jarvis = 0;

      Serial.println("Extinction LED");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x12)//Smog OFF
    {

      jarvis = 0;
      Serial.println("Smog OFF");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x13)//Arrêt du turbo
    {

      jarvis = 0;

      Serial.println("turbo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14)//Stop demo flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15)//Arrêt Demo
    {

      jarvis = 0;

      Serial.println("Demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial.write(0xAA);
      Serial.write(0x00);
      delay(100);
      Serial.write(0xAA);
      Serial.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }

}

Je reste naturellement à votre disposition et vous remercie d'avance pur votre intérêt..

:warning:
Post mis dans la mauvaise section, on parle anglais dans les forums généraux. déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans Les bonnes pratiques du Forum Francophone

Bonjour,

Je vois ça

mais tu n'utilises jamais Serial1. Donc j'en déduis que tu utilises Serial pour dialoguer avec ton module ET le moniteur série ce qui doit poser des problèmes.
Peut-être que si tu donnais un peu plus de détails sur ta configuration on pourrait t'aider plus efficacement.

Désolé, avec toutes mes excuses je serais plus attentif la prochaine fois, merci de l'avoir déplacé au bon endroit..

Bonjour FDFNEWS

merci pour ta réponse

Je n'utilise pas SERIAL1 car il n'apparaîssait dans aucun des programmes que j'ai vu lors de mes recherches. Mais tous les indices sont bon à prendre dans ma situation. De que j'avais cru comprendre Serial était nécessaire que si on utilise plusieur ports TX RX

Point de vue configuration:

  • un arduino Mega

  • un module de reconnaissance vocale Geeetech où j'enregistre préalablement les ordres avec
    HTerm

  • un adaptateur MicroSD card pour le stockage 1 des réponses de Jarvis format Wav et des
    morceaux de musique pour la fonction musique.

  • un PAM8403 2x3W Stereo Amplificateur

  • un TMP36 pour la détection de la température intérieur du casque

  • un Haut paleur 0.5W 8H

  • 1 buzzer

  • 4 led 3mm rouge pour l'éclairage des yeux

  • 1 moteur DC 3V pour l'hélice du réacteur dorsale

  • 4 servos metal type SG90 pour les flaps alimentation externe

  • 2 servos metal type SG90 pour l'ouverture du masque alimentation externe

  • 1 générateur de fumée

les contraintes pour cette commande vocale et que Jarvis réponde à son nom.
donc la 1ère commande sera toujours Jarvis il répondra aléatoirement par des réponses pré-enregistrées au format Wav su la carte SD.

J'aurais peut être pu utiliser un Uno mais par la suite je devrais encore gérer tout le côté hydrogène donc j'i prévu de la réserve avec la Mega.

Pour l'instant avec cette ébauche programme jarvis répond correctement et les 5 premières commandes du groupe 1, (0x21) également, à savoir Jarvis, Mask, Allumage, extinction et musique.

Suite aux ordres allumage et extinction je devrais pouvoir commander les 5 fonctions suivantes du groupe 2, (0x22) soit les rétroéclairages, la fumée, la rotation du réacteur, les flaps et un mode démo.

Oui, mais il faut que ton logiciel colle avec ton matériel et que ton matériel colle avec ton besoin.
Serial est la liaison série utilisée pour le téléchargement et pour afficher des retours dans le moniteur série pendant la mise au point. Donc, il y a du traffic sur cette liaison.

La mega 2560 possède 4 liaisons série matérielle.

Si tu connectes ton module vocal sur les broches D19 et D18, comme indiqué dans les commentaires au début de ton code, il faut que les échanges entre ton module vocal et la mega2560 se fassent en utilisant Serial1.

Si tu as connecté ton module vocal sur Serial, comme le laisse supposer ton code, lorsque tu fais des Serial.print() pour tracer l'exécution de ton programme cela doit perturber le module vocal qui doit voir passer des messages qu'il ne comprend pas.

Dans la mesure où la mega2560 possède plusieurs liaisons série, il n'est pas idiot de séparer les usages:

  • Serial pour la mise au point (téléchargement et messages de débogage)
  • Serial1 ou Serial2 ou Serial3 pour piloter ton module vocal.

si je supprime les Serial.print cela pourrait'il suffir à rêgler mon problème d'accès au second groupe d'ordres?
Je les ai mis là juste pour avoir un contrôle visuel de cequi ce passe en arrière plan sinon je n'en ai pas besoin..

Voici le programme de base sur lequel je me suis inspiré.. c'est le seul que j'ai trouvé qui utilise au moins 2 groupe de 5 ordres, tous les autres n'allumaient au plus que 5 les..
il tourne sur un Nano et effectivement il n'y a pas de Serial.print

///////////////////////////////////////////////
//////////   rappel connectique   /////////////
///////////////////////////////////////////////
/*
  ARDUINO ||  COMPOSANTS
  TX      ||  RX module vocal
  RX      ||  TX module vocal
  D2      ||  relais lumiere
  D3      ||  relais bureau
  D4      ||  cube
  D5      ||  ecritaux "guiguidem"
  D6      ||
  D7      ||
  D8      ||
  D9      ||  + du Haut Parleur
  D10    ||  CS lecteur SD
  D11    ||  MOSI lecteur SD
  D12    ||  MISO lecteur SD
  D13    ||  SCK lecteur SD
  5V       ||  lecteur SD + module vocal + relais + relais
  GND   ||  lecteur SD + - du HP + module vocal + cube + relais + relais + ecritaux
*/




///////////////////////////////////////////////
//////////  blibliothèque speaker /////////////
///////////////////////////////////////////////
#include <pcmConfig.h>
#include <pcmRF.h>
#include <TMRpcm.h>

#include <SD.h>

#define SD_Pin 10               //define CS pin

TMRpcm speaker;                 //objet "speaker


///////////////////////////////////////////////
//////////  variables des sorties /////////////
///////////////////////////////////////////////
int lumiere = 2;
int bureau = 3;
int cube = 4;
int nom = 5;
int temoin = 6;
int voix;


byte mess = 0;

int jarvis = 0;
bool allume;
bool eteind;
bool silence = 0;
bool parle = 1;

void setup() {


  Serial.begin(9600);


  ///////////////////////////////////////////////
  //////////  déclaration speaker ///////////////
  ///////////////////////////////////////////////
  speaker.speakerPin = 9;         //définnie le pin du speaker. Il faut utiliser le 9 car la library utilise ce pin !

  if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
    return;
  }
  speaker.setVolume(6);           //volume level : 0 to 7


  ///////////////////////////////////////////////
  ///////////  déclaration sortie ///////////////
  ///////////////////////////////////////////////
  pinMode(lumiere, OUTPUT);
  pinMode(bureau, OUTPUT);
  pinMode(cube, OUTPUT);
  pinMode(nom, OUTPUT);
  pinMode(temoin, OUTPUT);

  ///////////////////////////////////////////////
  ///////////// sortie éteinte //////////////////
  ///////////////////////////////////////////////
  digitalWrite(lumiere, HIGH);
  digitalWrite(bureau, HIGH);
  digitalWrite(cube, LOW);
  digitalWrite(nom, LOW);
  digitalWrite(temoin, LOW);


  ///////////////////////////////////////////////
  ////////////// module micro ///////////////////
  ///////////////////////////////////////////////
  Serial.write(0xAA);
  Serial.write(0x00);//attente
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x37);//Compact mode
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x00);//attente
  delay(100);
  Serial.write(0xAA);
  Serial.write(0x21);//importe groupe 1

}





void loop() // run over and over again
{

  while (Serial.available())
  {
    mess = Serial.read();  //recoit le message et le stock dans la variable mess



    ///////////////////////////////////////////////
    //////////////// reveille /////////////////////
    ///////////////////////////////////////////////
    if ((jarvis == 0) && (mess == 0x11)) //jarvis
    {
      if (parle == 1) {
        voix = random(1, 8);                       //random de 1 à 7
        delay (500);

        if (voix == 1) {
          speaker.play("1.wav");
        }
        if (voix == 2) {
          speaker.play("2.wav");
        }
        if (voix == 3) {
          speaker.play("3.wav");
        }
        if (voix == 4) {
          speaker.play("4.wav");
        }
        if (voix == 5) {
          speaker.play("5.wav");
        }
        if (voix == 6) {
          speaker.play("6.wav");
        }
        if (voix == 7) {
          speaker.play("7.wav");
        }

      }

      jarvis = 1;
      digitalWrite(temoin, HIGH);
    }

    ///////////////////////////////////////////////
    ///////////////// ordre ///////////////////////
    ///////////////////////////////////////////////
    if (jarvis == 1) {
      if (mess == 0x12) //allume
      {
        jarvis = 3;
        allume = 1;
        eteind = 0;
        delay(10);
        Serial.write(0xAA);
        Serial.write(0x00);
        delay(100);
        Serial.write(0xAA);
        Serial.write(0x22);
        delay(100);
        mess = 0x00;

      }


      if (mess == 0x13) //eteind
      {
        jarvis = 3;
        eteind = 1;
        allume = 0;
        delay(10);
        Serial.write(0xAA);
        Serial.write(0x00);
        delay(100);
        Serial.write(0xAA);
        Serial.write(0x22);
        delay(100);
        mess = 0x00;
      }


      if (mess == 0x14) //silence
      {
        jarvis = 0;
        silence = 1;
        parle = 0;
        digitalWrite(temoin, LOW);
        mess = 0x00;
      }


      if (mess == 0x15) //parle
      {
        jarvis = 0;
        parle = 1;
        silence = 0;
        digitalWrite(temoin, LOW);
        mess = 0x00;
      }

    }



    ///////////////////////////////////////////////
    //////////////// allumage /////////////////////
    ///////////////////////////////////////////////
    if (jarvis == 3) {

      if (allume == 1) {

        if (mess == 0x11) //lumiere
        {
          digitalWrite(2, LOW);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x12) //bureau
        {
          digitalWrite(3, LOW);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x13) //cube
        {
          digitalWrite(4, HIGH);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x14) //nom
        {
          digitalWrite(5, HIGH);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x15) //tout
        {
          for (int k = 2 ; k < 4 ; k++) {
            digitalWrite(k, LOW);
          }
          for (int l = 4 ; l < 6 ; l++) {
            digitalWrite(l, HIGH);
          }
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }
      }                                               //fin if (allume == 1)



      ///////////////////////////////////////////////
      //////////////// extinction ///////////////////
      ///////////////////////////////////////////////
      if (eteind == 1) {

        if (mess == 0x11)//lumiere
        {
          digitalWrite(2, HIGH);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x12)//bureau
        {
          digitalWrite(3, HIGH);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x13)//cube
        {
          digitalWrite(4, LOW);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x14)//nom
        {
          digitalWrite(5, LOW);
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }

        if (mess == 0x15)//tout
        {
          for (int k = 2 ; k < 4 ; k++) {
            digitalWrite(k, HIGH);
          }
          for (int l = 4 ; l < 6 ; l++) {
            digitalWrite(l, LOW);
          }
          jarvis = 0;
          digitalWrite(temoin, LOW);
          delay(10);
          Serial.write(0xAA);
          Serial.write(0x00);
          delay(100);
          Serial.write(0xAA);
          Serial.write(0x21);
          delay(100);
          mess = 0x00;
        }
      }                                                //fin if (eteind == 1)
    }                                               //fin if (jarvis == 3)
  }
}


Dans groupe ordre puis allume il y a Serial.write(0x22); qui devrait charger le groupe de 5 ordres suivants.
j'espère que cela pourra t'aider à voir plus claire dans ce que j'essaye de réaliser

Sans doute mais tu te prives d'un outil qui peut rendre service pendant le développement.
Pourquoi tu ne veux pas passer la liaison série du module vocal sur Serial1 et ainsi conserver Serial pour la mise au point? C'est quand même pratique de disposer d'un affichage d'informations pendant la mise au point du logiciel.

1 Like

hello
je dirais même plus, c'est indispensable.

merci pour ta réponse
en fait ce n'est pas que je ne veuille pas c'est plutôt que c'est une opération que je n'ai jamais eu l'occasion de faire mais il y a un début à tout.
si tu un conseil à me donner pour mettre ca en place je suis preneur..!

ca commencerait par quelque chose qui ressemblerait à ca?

#include <SoftwareSerial.h>

const byte rxPin = 0;
const byte txPin = 1;


SoftwareSerial geeetech =  SoftwareSerial(rxPin, txPin);

void setup () {
geeetech.begin(9600);

pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);


toujours pour la Mega.. d'ailleur j'étais déjà sur ces pin RX/TX

ce que je ne comprends pas c'est après, je dois faire quelque chose pour transmettre les données sur ces ports ou ca ce fait tout seul..?

Mais tu n'as pas besoin de softwareSerial puisque la mega dispose de 4 port série matériel.

Il suffit juste de connecter le module vocal en D18 et D19 (comme indiqué dans les commentaires de ton code), remplacer les Serial.write() par des Serial1.write et c'est tout
Comme ça:

  • Serial.print() ira vers l'IDE Arduino (téléchargement et moniteur série)
  • Serial1.write() ira vers le module vocal

hello
j'ai fais la modif du serial1 sur ton programme,

/////////////////////////////////////////////////////
//////////   rappel connectique   //////////////
////////////////////////////////////////////////////
/*
  ARDUINO ||  COMPOSANTS MEGA 2560
  D19 TX  ||  RX module vocal
  D18 RX  ||  TX module vocal
  D2      ||
  D3      ||
  D4      ||
  D5      ||  + du Buzzer
  D6      ||
  D7      ||
  D8      ||
  D9      ||
  D10    ||
  D11    ||
  D12    ||
  D13    ||
  D46    ||  + du Haut Parleur
  D50    ||  MISO lecteur SD
  D51    ||  MOSI lecteur SD
  D52    ||  SCK lecteur SD
  D53    ||  CS lecteur SD
  5V       ||  lecteur SD + module vocal + relais + relais
  GND   ||  lecteur SD + - du HP + module vocal + cube + relais + relais + ecritaux
*/




//////////////////////////////////////////////////////////////////////////////////
/////  Bibliothèque des sons disponibles  ///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
//// S_CONNECTION   S_DISCONNECTION S_BUTTON_PUSHED  //
//// S_MODE1        S_MODE2         S_MODE3  //////////////////////////
//// S_SURPRISE     S_OHOOH         S_OHOOH2 ///////////////////////
//// S_CUDDLY       S_SLEEPING      S_HAPPY  //////////////////////////
//// S_SUPER_HAPPY  S_HAPPY_SHORT   S_SAD    ////////////////////
//// S_CONFUSED     S_FART1         S_FART2  ///////////////////////////
//// S_FART3        S_JUMP 20                ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////




///////////////////////////////////////////////////////
////////////////////  Librairies  /////////////////////
///////////////////////////////////////////////////////
#include <pcmConfig.h>            // Library lecture Wav
#include <pcmRF.h>                // Library lecture Wav
#include <TMRpcm.h>               // Library lecture Wav
#include <Servo.h>                // Librairie Servo
#include <SD.h>                   // Library Carte SD
#define SD_Pin 53                 //define CS pin ATTENTION SI AUTRE BOARD!!
#include <CuteBuzzerSounds.h>     //librairie buzzer
#include <Sounds.h>               //librairie buzzer      
#include <TMP36.h>                // Librairie TMP36
#include <Wire.h>                 // Must include Wire library for I2C
#include <Servo.h>                // Librairie Servo




/////////////////////////////////////////////////////////////
///////////////  variables des sorties  /////////////////
////////////////////////////////////////////////////////////

Servo servoG;               // créer objet servo gauche
Servo servoD;               // créer objet servo droit

TMRpcm speaker;             //objet "speaker

int temoin = 13;            //led arduino uno pour nano = 6  et 13 our Mega!!

byte mess = 0;              //variable de stockage du message

int jarvis = 0;
int voix;                   //voix de Jarvis
int musique;                 //musique à disposition

bool allume;
bool eteind;

int etatMasque = 0;         //stock l'état du masck  0=masque fermé / 1=masque ouvert
int etatLed = 0;            //stock l'état du rétroéclairage 0=éteind / 1=allumé
int etaTech = 0;            //stock l'état d'appel du second groupe d'ordres
int etaTurbine = 0;         //stock l'état de la turbine
int etatMusique = 0;        //stock l'état de la lecture de la musique

const int sensor = 4;         // sensor créé sur pin 4
int lastState = LOW;          // etat précédent du sensor
int currentState;                   // la lecture actuelle du sensor
const int relais = 2;             // relais allumage yeux créé sur pin 2
const int ledChauffe = 3;   // led contrôle surchauffe créée sur pin 3





void setup() {

  Serial1.begin(9600);   //initialise le port de reception des ordres
  Serial.begin(115200);  // initialise le port de com avec le moniteur

  /////////////////////////////////////////////////////////////////
  ///////////////// déclaration speaker /////////////////////
  ////////////////////////////////////////////////////////////////
  speaker.speakerPin = 46;    //définnie le pin du speaker.

  if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
    return;
  }
  speaker.setVolume(5);           //volume level : 0 to 7


  ///////////////////////////////////////////////////
  ///////////  déclaration sortie ///////////////
  //////////////////////////////////////////////////

  pinMode(temoin, OUTPUT);

  //////////////////////////////////////////////////
  ///////////// sortie éteinte //////////////////
  /////////////////////////////////////////////////

  digitalWrite(temoin, LOW);


  /////////////////////////////////////////////////////
  ////////////// module micro ///////////////////
  ////////////////////////////////////////////////////

  Serial1.write(0xAA);
  Serial1.write(0x00);//attente
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x37);//Compact mode
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x00);//attente
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x21);//importe groupe 1

}



void loop()
{

  while (Serial1.available())
  {
    mess = Serial1.read();  //recoit le message et le stock dans la variable mess



    ////////////////////////////////////////////////
    //////////////// reveil /////////////////////
    ///////////////////////////////////////////////

    if ((jarvis == 0) && (mess == 0x11)) //jarvis
    {

      Serial.println("Jarvis");

      voix = random(1, 8);                       //random de 1 à 7
      delay (500);

      if (voix == 1) {
        speaker.play("1.wav");
      }
      if (voix == 2) {
        speaker.play("2.wav");
      }
      if (voix == 3) {
        speaker.play("3.wav");
      }
      if (voix == 4) {
        speaker.play("4.wav");
      }
      if (voix == 5) {
        speaker.play("5.wav");
      }
      if (voix == 6) {
        speaker.play("6.wav");
      }
      if (voix == 7) {
        speaker.play("7.wav");
      }

    }

    jarvis = 1;
    digitalWrite(temoin, HIGH);


  }


  //////////////////////////////////////////////////
  ///////////////// Ordres //////////////////////
  /////////////////////////////////////////////////

  if (jarvis == 1) {
    if ((mess == 0x12) && (etatMasque == 0)) //ouverture masque
    {
      jarvis = 0;
      etatMasque = 1;
      Serial.println("Ouvre masque");

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;                  //variable mess remise à zero

    }


    if ((mess == 0x12) && (etatMasque == 1)) //ferme masque
    {
      jarvis = 0;
      etatMasque = 0;
      Serial.println("Ferme masque");

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;

    }



    if ((mess == 0x15) && (etatMusique == 0)) //passe de la la musique aléatoirement
    {
      jarvis = 0;
      etatMusique = 1;

      Serial.println("Musique ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if ((mess == 0x15) && (etatMusique == 1)) //éteind la musique
    {
      jarvis = 0;
      etatMusique = 0;

      Serial.println("Musique OFF");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);                     // appel le 1er groupe d'ordre
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Allumage
    {
      jarvis = 3;
      allume = 1;
      eteind = 0;
      Serial.println("Allumes");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x22);                // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x14) //Extinction
    {
      jarvis = 3;
      eteind = 1;
      allume = 0;
      Serial.println("Eteinds");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x22);               // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
  }

  //////////////////////////////////////////////////
  //////////////// allumage /////////////////////
  //////////////////////////////////////////////////

  if ((jarvis == 3) && (allume == 1)) {


    if (mess == 0x11) //Led allumées
    {
      jarvis = 0;

      Serial.println("Led ON");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x12) //Smog actif
    {

      jarvis = 0;

      Serial.println("Smog ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Turbine en rotation
    {

      jarvis = 0;

      Serial.println("Turbo ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14) //Flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo start");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15) //Enclenche la demo
    {

      jarvis = 0;

      Serial.println("Demo active");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }
  ///////////////////////////////////////////////
  //////////////// extinction ///////////////////
  ///////////////////////////////////////////////
  if ((jarvis == 3) && (eteind == 1)) {

    if (mess == 0x11)//Extinction LED
    {

      jarvis = 0;

      Serial.println("Extinction LED");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x12)//Smog OFF
    {

      jarvis = 0;
      Serial.println("Smog OFF");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x13)//Arrêt du turbo
    {

      jarvis = 0;

      Serial.println("turbo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14)//Stop demo flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15)//Arrêt Demo
    {

      jarvis = 0;

      Serial.println("Demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }
///////////////////////////////////////////////
      //////////////// extinction ///////////////////
      ///////////////////////////////////////////////
      if (etatMasque == 1) {

        if (mess == 0x11)//fermeture
        {
          digitalWrite(2, HIGH);
          jarvis = 0;
          digitalWrite(temoin, LOW);
}

raccordes ton module sur 18 et 19
et passes ton moniteur en 115200 bauds

Je crois que le loup est encore dans la bergerie..

ce qui fonctionnait avant ne fonctionne plus et le reste ne fonctionne toujour pas :sweat_smile: :thinking: en plus mon module de reconnaissance s'affolle toutes le 30sec, clignotte comme si il était en configuration et je dois rebooter la Mega à chaque fois..

Mets ton code, on parle dans le vide.
Ajoutes des Serial.print() pour voir où passe le programme et si nécessaire fait afficher quelques variables pour comprendre ce qui va de travers.

hello fdufnews pas faut excuses moi..

du coups j'ai remplacé les Serial.write() par des Serial1.write.
j'ai changé Serial.begin(115200); j'ai quand même fait l'essai en 9600 mais idem..
maintenant jarvis ne répond plus du tout et à part musique et masque qui fonctionnent et
l'appel des ordres allumage et extinction qui s'affichent sur le moniteur série mais ne passe toujours pas au groupe d'ordre suivant. Etrangement le module de reconnaissance vocale part en vrille assez rapidement et clignotte comme lors de son paramètrage avec Hterm il faut rebooter la mega pour qu'il retrouve son mode de fonctionnement normale ce qu'il ne faisait pas avant la communication série séparée. Mes Serial.print s'affichent correctement et maintenant il n'y a plus de caractères parasites.

Qu'en penses tu?





///////////////////////////////////////////////
//////////   rappel connectique   /////////////
///////////////////////////////////////////////
/*
  ARDUINO ||  COMPOSANTS MEGA 2560
  D19 TX  ||  RX module vocal
  D18 RX  ||  TX module vocal
  D2      ||
  D3      ||
  D4      ||
  D5      ||  + du Buzzer
  D6      ||
  D7      ||
  D8      ||
  D9      ||
  D10     ||
  D11     ||
  D12     ||
  D13     ||
  D46     ||  + du Haut Parleur
  D50     ||  MISO lecteur SD
  D51     ||  MOSI lecteur SD
  D52     ||  SCK lecteur SD
  D53     ||  CS lecteur SD
  5V      ||  lecteur SD + module vocal + relais + relais
  GND     ||  lecteur SD + - du HP + module vocal + cube + relais + relais + ecritaux
*/




///////////////////////////////////////////////////////
/////  Bibliothèque des sons disponibles  /////////////
///////////////////////////////////////////////////////
//// S_CONNECTION   S_DISCONNECTION S_BUTTON_PUSHED  //
//// S_MODE1        S_MODE2         S_MODE3  //////////
//// S_SURPRISE     S_OHOOH         S_OHOOH2 //////////
//// S_CUDDLY       S_SLEEPING      S_HAPPY  //////////
//// S_SUPER_HAPPY  S_HAPPY_SHORT   S_SAD    //////////
//// S_CONFUSED     S_FART1         S_FART2  //////////
//// S_FART3        S_JUMP 20                //////////
///////////////////////////////////////////////////////




///////////////////////////////////////////////////////
////////////////////  Librairies  /////////////////////
///////////////////////////////////////////////////////
#include <pcmConfig.h>            // Library lecture Wav
#include <pcmRF.h>                // Library lecture Wav
#include <TMRpcm.h>               // Library lecture Wav
#include <Servo.h>                // Librairie Servo
#include <SD.h>                   // Library Carte SD
#define SD_Pin 53                 //define CS pin ATTENTION SI AUTRE BOARD!!
#include <CuteBuzzerSounds.h>     //librairie buzzer
#include <Sounds.h>               //librairie buzzer      
#include <TMP36.h>                // Librairie TMP36
#include <Wire.h>                 // Must include Wire library for I2C
#include <Servo.h>                // Librairie Servo
//#include <SoftwareSerial.h>


/////////////////////////////////////////////////////////
///////////////  variables des sorties  /////////////////
/////////////////////////////////////////////////////////
Servo servoG;               // créer objet servo gauche
Servo servoD;               // créer objet servo droit

TMRpcm speaker;             //objet "speaker

int temoin = 13;            //led arduino uno pour nano = 6  et 13 our Mega!!

byte mess = 0;              //variable de stockage du message

int jarvis = 0;
int voix;                   //voix de Jarvis
int musique;                 //musique à disposition

bool allume;
bool eteind;

int etatMasque = 0;         //stock l'état du masck  0= fermé / 1= ouvert
int etatLed = 0;            //stock l'état du rétroéclairage 0=éteind / 1=allumé

int etatMusique = 0;        //stock l'état du lecteur de musique

const int sensor = 4;       // sensor créé sur pin 4
int lastState = LOW;        // etat précédent du sensor
int currentState;           // la lecture actuelle du sensor

const int relais = 2;       // relais allumage yeux créé sur pin 2
const int ledChauffe = 3;   // led contrôle surchauffe créée sur pin 3


//__________________________________________________________________________________________//



void setup() {
  Serial.begin(115200);      //initialise le moniteur série

  Serial1.begin(9600);   //initialise le port de reception des ordres

  ////////////////////////////////////////////////////////////
  /////////////////  déclaration speaker /////////////////////
  ////////////////////////////////////////////////////////////
  speaker.speakerPin = 46;         //définnie le pin du speaker.
  if (!SD.begin(SD_Pin)) {        // si carte non inceré, ne rien faire
    return;
  }
  speaker.setVolume(5);           //volume level : 0 to 7


  ///////////////////////////////////////////////
  ///////////  déclaration sortie ///////////////
  ///////////////////////////////////////////////



  pinMode(temoin, OUTPUT);

  ///////////////////////////////////////////////
  ///////////// sortie éteinte //////////////////
  ///////////////////////////////////////////////

  digitalWrite(temoin, LOW);


  ///////////////////////////////////////////////
  ////////////// module micro ///////////////////
  ///////////////////////////////////////////////
  Serial1.write(0xAA);
  Serial1.write(0x00);//attente
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x37);//Compact mode
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x00);//attente
  delay(100);
  Serial1.write(0xAA);
  Serial1.write(0x21);//importe groupe 1

}



void loop()
{

  while (Serial1.available())
  {
    mess = Serial1.read();  //recoit le message et le stock dans la variable mess



    ///////////////////////////////////////////////
    //////////////// reveille /////////////////////
    ///////////////////////////////////////////////



    if ((jarvis == 0) && (mess == 0x11)) //jarvis
    {

      Serial.println("Jarvis");

      voix = random(1, 8);                       //random de 1 à 7
      delay (500);

      if (voix == 1) {
        speaker.play("1.wav");
      }
      if (voix == 2) {
        speaker.play("2.wav");
      }
      if (voix == 3) {
        speaker.play("3.wav");
      }
      if (voix == 4) {
        speaker.play("4.wav");
      }
      if (voix == 5) {
        speaker.play("5.wav");
      }
      if (voix == 6) {
        speaker.play("6.wav");
      }
      if (voix == 7) {
        speaker.play("7.wav");
      }

    }

    jarvis = 1;
    digitalWrite(temoin, HIGH);


  }


  ///////////////////////////////////////////////
  ///////////////// Ordres //////////////////////
  ///////////////////////////////////////////////
  if (jarvis == 1) {
    if ((mess == 0x12) && (etatMasque == 0)) //ouverture masque
    {
      jarvis = 0;
      etatMasque = 1;

      Serial.println("Ouvre masque");

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;                  //variable mess remise à zero

    }


    if ((mess == 0x12) && (etatMasque == 1)) //ferme masque
    {
      jarvis = 0;
      etatMasque = 0;

      Serial.println("Ferme masque");

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);

      digitalWrite(temoin, LOW);
      mess = 0x00;

    }



    if ((mess == 0x15) && (etatMusique == 0)) //passe de la la musique aléatoirement
    {
      jarvis = 0;
      etatMusique = 1;

      Serial.println("Musique ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if ((mess == 0x15) && (etatMusique == 1)) //éteind la musique
    {
      jarvis = 0;
      etatMusique = 0;

      Serial.println("Musique OFF");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Allumage
    {
      jarvis = 3;
      allume = 1;
      eteind = 0;
      Serial.println("Allumes");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x22); // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x14) //Extinction
    {
      jarvis = 3;
      eteind = 1;
      allume = 0;
      Serial.println("Eteinds");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x22); // appel le second groupe d'ordre
      delay(100);
      mess = 0x00;
    }
  }
  ///////////////////////////////////////////////
  //////////////// allumage /////////////////////
  ///////////////////////////////////////////////
  if ((jarvis == 3) && (allume == 1)) {


    if (mess == 0x11) //Led allumées
    {
      jarvis = 0;

      Serial.println("Led ON");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x12) //Smog actif
    {

      jarvis = 0;

      Serial.println("Smog ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
    if (mess == 0x13) //Turbine en rotation
    {

      jarvis = 0;

      Serial.println("Turbo ON");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14) //Flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo start");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15) //Enclenche la demo
    {

      jarvis = 0;

      Serial.println("Demo active");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }
  ///////////////////////////////////////////////
  //////////////// extinction ///////////////////
  ///////////////////////////////////////////////
  if ((jarvis == 3) && (eteind == 1)) {

    if (mess == 0x11)//Extinction LED
    {

      jarvis = 0;

      Serial.println("Extinction LED");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x12)//Smog OFF
    {

      jarvis = 0;

      Serial.println("Smog OFF");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x13)//Arrêt du turbo
    {

      jarvis = 0;

      Serial.println("turbo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x14)//Stop demo flaps
    {

      jarvis = 0;

      Serial.println("Flaps demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

    if (mess == 0x15)//Arrêt Demo
    {

      jarvis = 0;

      Serial.println("Demo stop");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
  }

}

Si j'ai bien compris le fonctionnement de ton programme tu attends un ordre du premier groupe tu passes ensuite sur un autre groupe pour le mot suivant comme par exemple "ALLUMES" + "LED" ou "ETEINDS" + "SMOG"

Lorsque tu changes le groupe d'ordre, c'est que tu attends un nouveau mot. Il faudrait donc lire Serial1 pour connaitre le code du mot suivant.
Autre chose, lorsque tu envoies une commande, le module retourne une réponse ce serait bien de contrôler que la commande a été acceptée. A minima, ne pas travailler en mode compact et rediriger tous les caractères venant du module vers Serial pour voir ce que répond le module. Cela permettrait au moins en phase de mise au point de voir si des commandes erronées sont envoyées.

Exacte certain ordre du 1er groupe servent de transition en chargant le second groupe d'ordres après leur exectution puis l'ordre donnée du second groupe s'éxecute et recharge le 1er groupe d'ordres.
ce qui est dommage c'es que les 5 ordres des 3 groupes sont numérotées de la même facon 011,012,013,014,015 il y a donc confusion et quand je prononce l'ordre du second groupe il le reconnais vocalement mais execute l'ordre du 1er groupe et je ne peux pas changer cette numérotation.

ta proposition est logique je n'ai pas suffisamment de visuel sur ce qui ce passe en arrière plan. Mais comment puis je contrôler la réponse du module et comment savoir si elle a été acceptée. Grace à Serial.println()?
Je sais déjà que certaines commandes ne passent pas de la bonne facon ou ne passent pas du tout, mais il y en a aussi qui passent sans problème notamment celle qui ne demande pas de passer au second groupe après leur execution..
J'ai testé hors mode compact les résultats sont identiques mais comment puis je faire pour rediriger tous les caractères venant du module vers Serial..?

Ton code est assez lourd et la lecture en est difficile.
Je pense que l'enchaînement des ordres est mal géré.
Il faudrait gérer cela comme une machine à états.
C'est déjà partiellement le cas mais le fait que le code de l'action déclenché par l'ordre soit au milieu de la chaîne de tests alourdi la lecture et on perd le fil assez vite.
Je vais regarder comment rendre tout ça plus facile à gérer mais je ne serais pas libre toute la journée.
Si j'ai bien compris la logique des ordres cela donne quelque chose comme ceci


Dans la doc du module ils disent

you can speak or send voice instruction to it. If identified successfully, result will be returned via serial port in the format: group number + command number.

Donc un mot reconnu du second groupe devrait commencer par 2 et non par 1. Ainsi le premier mot du groupe 2 devrait retourner 0x21.
EDIT: après avoir vu un tuto sur ce module, il semblerait que la doc ne corresponde pas à la réalité et que les codes ne retournent pas le numéro du groupe.

if ((jarvis == 3) && (allume == 1)) {


    if (mess == 0x11) //Led allumées
    {
      jarvis = 0;

      Serial.println("Led ON");
      digitalWrite(temoin, LOW);

      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }
if ((jarvis == 3) && (eteind == 1)) {

    if (mess == 0x11)//Extinction LED
    {

      jarvis = 0;

      Serial.println("Extinction LED");
      digitalWrite(temoin, LOW);
      delay(10);
      Serial1.write(0xAA);
      Serial1.write(0x00);
      delay(100);
      Serial1.write(0xAA);
      Serial1.write(0x21);
      delay(100);
      mess = 0x00;
    }

puisque tu vois les messages s'afficher, c'est que la commande est bien reconnue.

ton code n'est pas fini:
ou est la commande "digitalWrite(leds,HIGH);"
ou est la commande "digitalWrite(leds,LOW);"

idem pour les autres périphériques