Voice recognize geeetech

Salve sono nuovo del forum e volevo un aiutino per risolvere il mio problema con il riconoscimento vocale.Premetto che che capisco poco di programmazione pero mi affascina la cosa. Tornando al problema il riconoscimento vocale funziona bene caricando un gruppo alla volta ma me interessava farli funzionare tutti,logicamente non contemporaneamente ma uno alla volta quando io lo richiamo.Ho un arduino uno ed allego il codice che sto utilizzando senza risultato.Come posso risolvere?

[/int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8
int diego=13;
//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition

void setup()
{
  Serial.begin(9600);
  //________________________
 // pinMode(13, OUTPUT);//inserito causa accensione fievole del led
  
  //_____________________________
      pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
      pinMode(redPin, OUTPUT); // sets the redPin to be an output
      pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
      pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
      pinMode(bbPin, OUTPUT);
      pinMode(diego,OUTPUT);
      delay(2000);
    Serial.write(0xAA);       // Invia comandi alla porta seriale
      Serial.write(0x37);
      delay(1000);
      Serial.write(0xAA);
      Serial.write(0x21);      //importa gruppo uno
  /*   */
  
}
void loop(){
  //----------------
  
   while (Serial.available())
        {
        com = Serial.read();
        Serial.println(com);
        switch (com)
        {
  diego=digitalRead(13);
  if (diego==HIGH){         
      Serial.write(0xAA);// Invia comandi alla porta seriale
      Serial.write(0x37);
      delay(1000);
      Serial.write(0xAA);
      Serial.write(0x22);}
   while (Serial.available())
        {
        com = Serial.read();
        Serial.println(com);
        switch (com)
        delay(2000);
  case 0x11://'cucina' parola per accendere (byte lettura17)
      
      //----------------------
          val1 = digitalRead(12);    // val1 variabile per lettura stato del  pin 12
          if (val1 == LOW) {         // Se il pin 12 è basso, quindi vera, accendi.Se invece è alto quindi falso vai ad else e spegni
          digitalWrite(12, HIGH);    //porta il pin 12 alto
          Serial.println("luci cucina accese");//invia il dato led acceso sul monitor seiale di arduino tornando a capo
          
        Serial.println(com);
          }
          else {
          digitalWrite(12, LOW);
          Serial.print("led spento");//invia il dato led acceso sul monitor seiale di arduino senza tornare  a capo
           }
          if (com==val9){
            digitalWrite(13,HIGH);}
            else {digitalWrite(13,LOW);
          }
     break;code]

Beh intanto il codice che hai postato è troncato (finisce con "break;").

Poi direi che sarebbe anche il caso di farlo formattare correttamente (apri l'IDE, carichi lo sketch, e premi Ctrl-T per farlo riformattare, quindi salvi), che consente a te di fare meglio il debug, ed a noi di capire più rapidamente la struttura. A parte poi evitare variabili con nomi privi di significato come "diego"...

Infine, come sempre, dovresti spiegare meglio cosa significa per te "un gruppo" (un comando vocale?), e "senza risultato" (cosa fa quando dai i comandi, e cosa quindi dovrebbe fare invece?).

PS la tua presentazione l'hai fatta, ma diciamo che qualcosina in più potresti scriverla su cosa conosci di elettronica e/o programmazione non ti pare? :slight_smile:

Salve ti ringrazio per la tua risposta.Riguardo al codice sto provvedendo a ripulirlo un po .Per il riconoscitore vocale so che è composto da tre gruppi ognuno formato da cinque comandi vocali e fin qui ci sono i tre gruppi funzionano perfettamente se li carico attraverso il void setup .Il mio problema è che se voglio cambiare o meglio switchare su un altro gruppo e quindi tramite software nel void loop non va, ho si impalla ho non riconosce per niente l'altro gruppo .Mi serviva uno spunto su come risolvere.

>Etabeta2018: .. ma il regolamento lo leggete ? ? ? :o

In conformità al regolamento, punto 7, devi editare il tuo post (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More -> Modify che si trova in basso a destra del tuo post) e racchiudere il codice all'interno dei tag CODE (... sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra).

In pratica, tutto il tuo codice dovrà trovarsi racchiuso tra due tag: [code] _il _tuo_ codice_ [/code] così da non venire interpretato e non dare adito alla formazione di caratteri indesiderati o cattiva formattazione del testo. Grazie.

Guglielmo

Ok chiedo scusa ho provveduto.

int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8

//-------------------------
int val1 = 0;
int val2 = 0;
int val3 = 0; 
int val4 = 0;
int val5 = 0;int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition


void setup()
{
  Serial.begin(9600);
  //________________________
  // pinMode(13, OUTPUT);//inserito causa accensione fievole del led

  //_____________________________
  pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
  pinMode(redPin, OUTPUT); 
  pinMode(greenPin, OUTPUT); 
  pinMode(bluePin, OUTPUT); 
  pinMode(bbPin, OUTPUT);

  delay(2000);
  Serial.write(0xAA);       // Invia comandi alla porta seriale
  Serial.write(0x37);
  delay(1000);
  Serial.write(0xAA);
  Serial.write(0x21);      //importa gruppo uno


}
void loop() {
  //----------------

  while (Serial.available())
  {
    com = Serial.read();
    Serial.println(com);

    switch (com)
    {
        val8 = digitalRead(13);
        if (val8 == HIGH) {
          Serial.write(0xAA);// Invia comandi alla porta seriale
          Serial.write(0x37);
          delay(2000);
          Serial.write(0xAA);
          Serial.write(0x22);
          delay(2000);
        }
        while (Serial.available())
        {
          com = Serial.read();

          Serial.println(com);
          switch (com)
            delay(2000);
        case 0x11:
          //----------------------
          val1 = digitalRead(12);   
          if (val1 == LOW) {         
            digitalWrite(12, HIGH);    
            Serial.println("luci cucina accese");

            Serial.println(com);
          }
          else {
            digitalWrite(12, LOW);
            Serial.print("led spento");          }
          if (com == val9) {
            digitalWrite(13, HIGH);
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        case 0x12:
          val8 = digitalRead(13);
          if (val8 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("luci   accese");
          }
          else {
            digitalWrite(12, LOW);
          }

          break;
        case 0x16:
          val5 = digitalRead(13);
          if (val5 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("Clima acceso");
            Serial.println(com);
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        }
    }
  }
}

Etabeta2018:
Il mio problema è che se voglio cambiare o meglio switchare su un altro gruppo e quindi tramite software nel void loop non va, ho si impalla ho non riconosce per niente l'altro gruppo .Mi serviva uno spunto su come risolvere.

Altra domanda vedendo "al volo" il tuo codice (che non posso provare non avendo quel device): tu usi il pin 13 come input per determinare quando cambiare gruppo, ma c'è un motivo preciso per aver scelto il 13 (che cerco sempre di evitare perché ha collegati un LED ed una resistenza)? Se possibile usa un altro pin, altrimenti per usarlo come ingresso dovresti dare esplicitamente pinMode() a INPUT e mettere una resistenza esterna di pull-down.

Poi da riga 44 a 50 vedo istruzioni che apparentemente non servono a nulla, secondo me devi toglierle perché in realtà queste cose le fai dentro al resto del codice:

  while (Serial.available())
  {
    com = Serial.read();
    Serial.println(com);

    switch (com)
    {

Insomma, verifica meglio la struttura del programma se corrisponde a quello che vorresti fare.

A parte queste cose, non vedo altri problemi, ma come detto non avendo la tua scheda vocale non posso fare test, quindi intanto togli quelle righe "anomale", modifica quel pin da 13 ad un altro e facci sapere.

Salve ho modificato il codice . Adesso sembra che vada in loop,dal monitor seriale riesco a leggere dei valori ⸮7⸮!0
0
248
204
255 e poi ripete il 255 all'infinito senza caricare nulla

int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8

//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition


void setup()
{
  Serial.begin(9600);
  //________________________
  // pinMode(13, OUTPUT);//inserito causa accensione fievole del led

  //_____________________________
  pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
  pinMode(redPin, OUTPUT); // sets the redPin to be an output
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
  pinMode(bbPin, OUTPUT);

  delay(2000);
  Serial.write(0xAA);       // Invia comandi alla porta seriale
  Serial.write(0x37);
  delay(1000);
  Serial.write(0xAA);
  Serial.write(0x21);      //importa gruppo uno


}
void loop() {
  //----------------

  while (Serial.available())
  {
    com = Serial.read();
    Serial.println(com);

    switch (com)
    {
        val8 = digitalRead(12);
        if (val8 == HIGH) {
          Serial.write(0xAA);// Invia comandi alla porta seriale
          Serial.write(0x37);
          delay(2000);
          Serial.write(0xAA);
          Serial.write(0x22);
          delay(2000);
        }
        
        case 0x11://'cucina' parola per accendere (byte lettura17)

          //----------------------
          val1 = digitalRead(12);    // val1 variabile per lettura stato del  pin 12
          if (val1 == LOW) {         // Se il pin 12 è basso, quindi vera, accendi.Se invece è alto quindi falso vai ad else e spegni
            digitalWrite(12, HIGH);    //porta il pin 12 alto
            Serial.println("luci cucina accese");//invia il dato led acceso sul monitor seiale di arduino tornando a capo

            Serial.println(com);
          }
          else {
            digitalWrite(12, LOW);
            Serial.print("led spento");//invia il dato led acceso sul monitor seiale di arduino senza tornare  a capo
          }
          if (com == val9) {
            digitalWrite(11, HIGH);
          }
          else {
            digitalWrite(11, LOW);
          }
          break;
        case 0x12://stanza uno(byte lettura18)
          val8 = digitalRead(10);
          if (val8 == LOW) {
            digitalWrite(10, HIGH);
            Serial.println("luci   accese");
          }
          else {
            digitalWrite(10, LOW);
          }

          break;
        case 0x16://clima
          val5 = digitalRead(13);
          if (val5 == LOW) {
            digitalWrite(9, HIGH);
            Serial.println("Clima acceso");
            Serial.println(com);
          }
          else {
            digitalWrite(9, LOW);
          }
          break;
        }
    }
  }

//---------------------

Scusa una domanda, ma se come mi sembra di capire la seriale serve per il dialogo con lo speech recognition, io credo che non gli piaccia che tu ci fai altre cose, soprattutto se ci attacchi il monitor seriale e vai a scrivere cose!!!

Se vuoi tenere il monitor seriale per tuo debug, credo che tu possa/debba usare la SoftwareSerial e collegare lo speech ad altri pin diversi da 0 ed 1, diciamo 10 e 11 ad esempio. A quel punto se scrivi sulla normale Serial mandi al monitor, se scrivi a quella software parli con la periferica!

Detto questo, i primi caratteri che vedi, "⸮7⸮!" e vanno bene, sono i primi 4 write che fai nel setup() infatti 0x37 corrisponde al carattere "7" ad esempio.

Se usi la SoftwareSerial ad esempio chiamata Serial1, ti consiglierei di mandare sul monitor i valori esadecimali di ciò che ricevi, quindi farai una cosa del genere:

  delay(2000);
  invia(0xAA);       // Invia comandi alla porta seriale
  invia(0x37);
  delay(1000);
  invia(0xAA);
  invia(0x21);      //importa gruppo uno

quindi una funzioncina che manda i dati su entrambe le seriali, su quella software manda il byte, su quella del monitor ci manda il valore esadecimale:

void invia(byte valore) {
  Serial1.write(valore);
  Serial.print(valore, HEX);
  Serial.print(" ");
}

Prova e facci sapere!

Ok credo di aver capito qualcosa, proverò a modificare con la softwareserial e ti faro sapere .Grazie

Prima di tutto grazie per la piccola dritta che mi hai dato.Va meglio,adesso posso inviare direttamente il codice senza ogni volta scollegare i cavi rx,tx dallo 0,1 .pero debbo aver fatto un po di confusione ,il voice adesso sembra non impallarsi più risponde quasi sempre hai comandi,solo che si attiva con tutti i comandi vocali sia quelli del G1 che quelli del G2 non riesce a discriminare i due gruppi ed inoltre non riesco più a visualizzare informazioni sul monitor seriale dell'ide.Come avrai ben capito di programmazione sono a zero.

#include <SoftwareSerial.h>

int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8
int bbpin=13;
//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition

#include <SoftwareSerial.h>
SoftwareSerial Serial1(5, 6); // RX, TX
void setup()
{

  Serial1.begin(9600);
  //________________________
  // pinMode(13, OUTPUT);//inserito causa accensione fievole del led

  //_____________________________
  pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
  pinMode(redPin, OUTPUT); // sets the redPin to be an output
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
  pinMode(bbPin, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Serial1.write(0xAA);       // Invia comandi alla porta seriale
  Serial1.write(0x37);
  delay(1000);
  Serial1.write(0xAA);
  Serial1.write(0x21);      //importa gruppo uno


}
void loop() {
  //----------------

  while (Serial1.available())
  {
    com = Serial1.read();
    Serial1.println(com);
    Serial.print("");
    switch (com)
    {
        val8 = digitalRead(12);
        if (val8 == HIGH) {
          Serial1.write(0xAA);// Invia comandi alla porta seriale
          Serial1.write(0x37);
          delay(2000);
          Serial1.write(0xAA);
          Serial1.write(0x22);
          delay(2000);
        }
        while (Serial1.available())
        {
          com = Serial1.read();

          Serial1.println(com);
          switch (com)
            delay(2000);

        case 0x11://'cucina' parola per accendere (byte lettura17)

          //----------------------
          val1 = digitalRead(12);    // 
          if (val1 == LOW) {         // 
            digitalWrite(12, HIGH);    //porta il pin 12 alto
            Serial1.println("luci cucina accese");//invia il dato led acceso sul monitor seiale di arduino tornando a capo

            Serial.println(com);
          }
          else {
            digitalWrite(12, LOW);
            Serial1.print("led spento");//invia il dato led acceso sul monitor seiale di arduino senza tornare  a capo
          }

          break;
        case 0x12://stanza uno(byte lettura18)
          val8 = digitalRead(13);
          if (val8 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("luci   accese");
          }
          else {
            digitalWrite(13, LOW);
          }

          break;
        case 0x13://
          val3 = digitalRead(10);
          Serial.println("luci stanza due accese");
          if (val3 == LOW) {
            digitalWrite(10, HIGH);
          }
          else {
            digitalWrite(10, LOW);
          }
          break;
        case 0x15://
          val5 = digitalRead(8);
          if (val5 == LOW) {
            digitalWrite(8, HIGH);
            Serial.println("Caldaia accesa");
          }
          else {
            digitalWrite(8, LOW);
          }
          break;
        case 0x16://clima
          val5 = digitalRead(13);
          if (val5 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("Clima acceso");
            Serial.println(com);
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        }
    }
  }
}
//---------------------

Etabeta2018:
Prima di tutto grazie per la piccola dritta che mi hai dato.Va meglio,adesso posso inviare direttamente il codice senza ogni volta scollegare i cavi rx,tx dallo 0,1 .pero debbo aver fatto un po di confusione

Allora, intanto vedo che non hai fatto tutto quello che ti avevo consigliato, poi anche qualche altra cosetta che provo ora ad elencarti (non ho molto tempo stamattina per vedere in dettaglio, ma ti dico le cose che mi sono venute più in evidenza):

  1. Hai messo due volte "#include <SoftwareSerial.h>", non causa problemi ma è inutile

  2. Non vedi niente sul monitor seriale perché nel setup() non hai fatto anche "Serial.begin(9600);" (hai messo solo Serial1)

  3. Quando ricevi un carattere da Serial1 e vuoi vederlo sul monitor seriale devi mandarlo a Serial, non a Serial1!

  while (Serial1.available())
  {
    com = Serial1.read();
    Serial1.println(com);  // Assolutamente NO, deve essere Serial.println()!!
    Serial.print("");

Per evitare confusioni, l'oggetto Serial1 chiamalo magari "Speech" così non ti sbagli più... :wink:

  1. In ogni caso ha qualche grosso problema di logica nella loop(), causato da troppi copia/incolla fatti senza capire (male, MALE!).
    Tu hai messo una "while (Serial1.available())", dentro alla quale leggi da Serial1, poi hai una "switch(com)" con un blocco di istruzioni non preceduto da nessun "case", seguito da un'altra "while" con una seconda lettura da Serial1 (la prima l'hai persa quindi), seguita da un altro "switch" ma privo delle sue graffe quindi i "case" successivi fanno parte del primo "switch"!! Insomma, scusa ma è un casino...
    Prima devi CAPIRE meglio cosa vuoi fare e come si usa la speech, e POI puoi impostare il codice. Ma se non sai ancora neanche le basi del C, la vedo un poco difficile...

Posso provare a farti qualche ritocco al codice, ma è NECESSARIO che tu inizi a capire il linguaggio quantomeno, ed un minimo della logica di gestione di questa cosa, perché in caso contrario ti dovremmo riscrivere noi daccapo tutto il codice... Non entro quindi nella logica ma questa bozza potrebbe essere per te almeno un punto di partenza:

#include <SoftwareSerial.h>

int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8
int bbpin=13;
//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition

#include <SoftwareSerial.h>
SoftwareSerial Speech(5, 6); // RX, TX
void setup()
{
  Serial.begin(9600);
  Speech.begin(9600);
  //________________________
  // pinMode(13, OUTPUT);//inserito causa accensione fievole del led

  //_____________________________
  pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
  pinMode(redPin, OUTPUT); // sets the redPin to be an output
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
  pinMode(bbPin, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Speech.write(0xAA);       // Invia comandi alla porta seriale
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);      //importa gruppo uno
}

void loop() {
	val8 = digitalRead(12);
	if (val8 == HIGH) {
	  Speech.write(0xAA);// Invia comandi alla porta seriale
	  Speech.write(0x37);
	  delay(2000);
	  Speech.write(0xAA);
	  Speech.write(0x22);
	  delay(2000);
	}
	while (Speech.available())
	{
	  com = Speech.read();
	  Serial.println(com);
	  switch (com) {
        case 0x11://'cucina' parola per accendere (byte lettura17)
          //----------------------
          val1 = digitalRead(12);    //
          if (val1 == LOW) {         // 
            digitalWrite(12, HIGH);    //porta il pin 12 alto
            Serial.println("luci cucina accese");//invia il dato led acceso sul monitor seiale di arduino tornando a capo
            Serial.println(com);
          }
          else {
            digitalWrite(12, LOW);
            Serial.println("led spento");//invia il dato led acceso sul monitor seiale di arduino senza tornare  a capo
          }
          break;
        case 0x12://stanza uno(byte lettura18)
          val8 = digitalRead(13);
          if (val8 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("luci   accese");
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        case 0x13://
          val3 = digitalRead(10);
          Serial.println("luci stanza due accese");
          if (val3 == LOW) {
            digitalWrite(10, HIGH);
          }
          else {
            digitalWrite(10, LOW);
          }
          break;
        case 0x15://
          val5 = digitalRead(8);
          if (val5 == LOW) {
            digitalWrite(8, HIGH);
            Serial.println("Caldaia accesa");
          }
          else {
            digitalWrite(8, LOW);
          }
          break;
        case 0x16://clima
          val5 = digitalRead(13);
          if (val5 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("Clima acceso");
            Serial.println(com);
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        }
    }
  }
}
//---------------------

Allora ti ringrazio di tutto e mi scuso per tutto il tempo che ti sto rubando, ma sto cercando di capire e imparare,e non voglio che tumi riscriva il codice ma solo che mi dica gli errori in modo tale che io possa capire e non ripeterli.Ho fatto altri cambiamenti su come mi hai consigliato(almeno credo).Ora sicuramente mi manderai a quel paese ,non fa niente.Parte del codice ,questo non per giustificarmi,lo so che lo incasinato anche a causa delle tante prove che ho fatto,fino a giungere al punto di non poterne più.Comunque non è cambiato molto il mio problema è che continua a non discriminare i due gruppi ,accetta i comandi di entrambi.Scusa una domanda ,ma non dovrei farli funzionare su due void separati tipo void 1 e void2 per tenera separata la gestione dei due gruppi?Questo è il nuovo codice P.S. Adesso sul monitor mi escono questi valori11
luci cucina accese
11
11111111 questo valore lo ripete all'infinito
led spento
15
Caldaia accesa
15

#include <SoftwareSerial.h>

int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8
int bbpin=13;
//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition


SoftwareSerial Speech(5, 6); // RX, TX
void setup()
{

  Serial.begin(9600);
  Speech.begin(9600);
  //________________________
  pinMode(13, OUTPUT);//inserito causa accensione fievole del led

  //_____________________________
  pinMode(ledPin, OUTPUT); // sets the ledPin to be an output
  pinMode(redPin, OUTPUT); // sets the redPin to be an output
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
  pinMode(bbPin, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Speech.write(0xAA);       // Invia comandi alla porta seriale
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);      //importa gruppo uno


}
void loop() {
  //----------------

 /* while (Serial1.available())
  {
    com = Serial1.read();
    Serial1.println(com);
    Serial.print("");
    switch (com)
      {
    */
        val8 = digitalRead(12);
        if (val8 == HIGH) {
          Speech.write(0xAA);// Invia comandi alla porta seriale
          Speech.write(0x37);
          delay(2000);
          Speech.write(0xAA);
          Speech.write(0x22);
          delay(2000);
        }
        while (Speech.available())
        {
          com = Speech.read();

          Serial.println(com);
          switch (com){
            

        case 0x11://'cucina' parola per accendere (byte lettura17)

          //----------------------
          val1 = digitalRead(12);    // val1 variabile per lettura stato del  pin 12
          if (val1 == LOW) {         // Se il pin 12 è basso, quindi vera, accendi.Se invece è alto quindi falso vai ad else e spegni
            digitalWrite(12, HIGH);    //porta il pin 12 alto
            Serial.println("luci cucina accese");//invia il dato led acceso sul monitor seiale di arduino tornando a capo

            Serial.println(com);
          }
          else {
            digitalWrite(12, LOW);
            Serial.print("led spento");//invia il dato led acceso sul monitor seiale di arduino senza tornare  a capo
          }

          break;
        case 0x12://stanza uno(byte lettura18)
          val8 = digitalRead(13);
          if (val8 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("luci   accese");
          }
          else {
            digitalWrite(13, LOW);
          }

          break;
        case 0x13://
          val3 = digitalRead(10);
          Serial.println("luci stanza due accese");
          if (val3 == LOW) {
            digitalWrite(10, HIGH);
          }
          else {
            digitalWrite(10, LOW);
          }
          break;
        case 0x15://
          val5 = digitalRead(8);
          if (val5 == LOW) {
            digitalWrite(8, HIGH);
            Serial.println("Caldaia accesa");
          }
          else {
            digitalWrite(8, LOW);
          }
          break;
        case 0x16://clima
          val5 = digitalRead(13);
          if (val5 == LOW) {
            digitalWrite(13, HIGH);
            Serial.println("Clima acceso");
            Serial.println(com);
          }
          else {
            digitalWrite(13, LOW);
          }
          break;
        }
    }
  }


//---------------------

Etabeta2018:
Parte del codice ,questo non per giustificarmi,lo so che lo incasinato anche a causa delle tante prove che ho fatto,fino a giungere al punto di non poterne più.

In questi casi però si fa prima appunto a ricominciare daccapo, ma cercando di fare una cosa per volta. Questo ti consente anche di capire meglio cosa fa ognuna delle cose che fai.

ma non dovrei farli funzionare su due void separati tipo void 1 e void2 per tenera separata la gestione dei due gruppi?

Non esistono void1 e void2, "void" significa solamente "nessun valore" ed è il tipo di dati ad esempio restituito da una funzione come loop() ad esempio. Quindi no, non puoi avere due loop().

Adesso sul monitor mi escono questi valori11
luci cucina accese
11
11111111 questo valore lo ripete all'infinito
led spento
15
Caldaia accesa
15

Uhm, intanto dal codice visto che di ogni byte ricevuto fai "Serial.println(com);" ogni valore dovrebbe andare a capo, non tutto di seguito come l'hai riportato. Sicuro che quello sia l'output copiato dal monitor seriale? O lo hai digitato tu?

Secondo, con "Serial.println(com);" visualizzi il valore in decimale, quindi visto che scrive "luci cucina accese" devo supporre che sia entrato nel case 0x11 che però è esadecimale quindi il print dovrebbe mostrarti 17 (il valore decimale del byte 0x11) e non 11...

Terzo, nel codice vedo che con "val1 = digitalRead(12);" leggi lo stato del pin 12 (ma se hai messo una variabile apposta per il numero di quel pin, perché non la usi?) poi se è HIGH lo metti LOW e fai il contrario se LOW. Se ti entra continuamente in quel "case" significa che Speech.available() è sempre true, ma non ho capito se legge sempre 0x11 e quindi continuamente attivi e disattivi il pin 12 o cosa fa. Qui non conosco il funzionamento dello speech quindi non so dirti perché vada a scriverti continuamente "11" (che poi sarebbe 17?)...

Quarto, all'inizio del loop() leggi anche qui il pin 12: perché sempre il 12? Non è un LED? O dovrebbe essere un altro pin, magari con un pulsante?

Poi ci sono anche altre questioni più che altro "stilistiche" ma ne parliamo magari quando il programma inizia a funzionare.

Tu cerca di capire come lo speech gestisce i dati sulla sua seriale, cancella le righe inutili o commentate e INDENTA il codice. Rivedi bene le numerazioni dei pin che usi, e per evitare confusione usa i NOMI delle variabili che definiscono i pin invece del numero (poi queste variabili le trasformerai in #define ma un passo alla volta).
E magari invece di "while (Speech.available())" metti un "if (Speech.available())" per evitare cicli infiniti, cambia un poco le scritture sul monitor seriale ossia rendilo più chiaro: evita le scritture inutili ad esempio togli la riga "Serial.println(com);" dopo la Speech.read() e lascia la scrittura solamente dentro ai "case" così scrive solo quando "riconosci" un byte, e fagli scrivere con qualcosa di più significativo, ad esempio:

void loop() {
  val8 = digitalRead(12); // QUALE PIN DEVE LEGGERE????
  if (val8 == HIGH) {
    Speech.write(0xAA);// Invia comandi alla porta seriale
    Speech.write(0x37);
    delay(2000);
    Speech.write(0xAA);
    Speech.write(0x22);
    delay(2000);
  }
  if(Speech.available())
  {
    com = Speech.read();
    switch (com){
      //----------------------
      case 0x11://'cucina' parola per accendere (byte lettura17)
	Serial.print("Ricevuto byte ");
        Serial.print(com, HEX);
        Serial.print(" - luci cucina ");
        val1 = digitalRead(ledPin);
        // Se il pin 12 è basso, quindi vera, accendi.
        if (val1 == LOW) {
          digitalWrite(12, HIGH);
	  Serial.println(" ACCESE");
          }
          else {
	    // Se invece è alto quindi falso vai ad else e spegni
            digitalWrite(12, LOW);
	    Serial.println(" ACCESE");
          }
          break;
		  
      //----------------------
        case 0x12://stanza uno(byte lettura18)
    ...eccetera

Salve dopo varie prove sono giunto alla conclusione che lo speech bisogna caricare un gruppo alla volta in quanto qualsiasi comando vocale io gli invio, registrato sempre nello stesso ordine sequenziale ,lui risponde sempre da uno a cinque o meglio da case 0x11 a case 0x15.Percui il primo comando del G1 equivale al primo del G2.ed al primo del G3 ed anche se ho caricato solo il primo pronunciando il primo di uno degli altri gruppi fa sempre la stessa cosa,ricevo sempre il byte 11.Penso o che sia andato in tilt,o che debba funzionare proprio cosi ,il che è na ciofeca.Ho provato anche con il codice riportato come esempio sul loro sito ma non cambia nulla.L'unica consolazione e che ho imparato qualche altra cosa sulla programmazione.Grazie e scusami per il tempo che ti ho rubato.Anche se penso che ti infastidiro di nuovo con altre problematiche

Etabeta2018:
Percui il primo comando del G1 equivale al primo del G2.ed al primo del G3 ed anche se ho caricato solo il primo pronunciando il primo di uno degli altri gruppi fa sempre la stessa cosa,ricevo sempre il byte 11.
Penso o che sia andato in tilt,o che debba funzionare proprio cosi ,il che è na ciofeca.

Non capisco bene. Se tu selezioni il G1 e pronunci la prima del gruppo, ti dà 0x11 e questo ci sta. Poi selezioni il G2 e pronunci la prima parola del gruppo 2, e anche qui ti dà (se ho capito bene) sempre 0x11, esatto?
Vedendo un poco di info in rete mi sembra che, nonostante il manuale dica diversamente, in Compact Mode sia proprio così che funzioni (la prima cifra non cambia in base al gruppo) ma in questo caso tu, sapendo quale gruppo hai selezionato (perché lo hai selezionato tu...) ti basta impostare il programma per fare una cosa diversa a seconda del gruppo corrente. Tu tieni in una variabile il numero del gruppo selezionato quindi quando ricevi un byte devi semplicemente distinguere se 0x11 è del gruppo 1 o 2.

Se hai difficoltà a modificare il programma posta il "nuovo" codice e vediamo, se invece è proprio qualcos'altro allora spiega anche meglio esattamente cosa fai e cosa ottieni.

Salve ho fatto qualche prova ma niente da fare riconosce sempre tutto,è esattamente come hai detto tu. Debbo solo provare a registrare tutto da capo .Adesso sono completamente impantanato.Questo è il codice modificato su tuo consiglio, ho tentato di aggiungere un'altra if ma niente da fare.

#include <SoftwareSerial.h>
int cuc = 12;
int uno = 11;
int due = 10;
int por = 9;
int cal = 8;
int cli = 13;
//-------------------------
int val1 = 0;
int val2 = 0;
int val3 = 0;
int val4 = 0;
int val5 = 0;
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
int g1=0x21;
int g2=0x22;
byte com = 0;
SoftwareSerial Speech(5, 6); // RX, TX
void setup()
{
  Serial.begin(9600);
  Speech.begin(9600);
  pinMode(cli, OUTPUT);//inserito causa accensione fievole del led
  pinMode(cuc, OUTPUT);
  pinMode(uno, OUTPUT);
  pinMode(due, OUTPUT);
  pinMode(por, OUTPUT);
  pinMode(cal, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Speech.write(0xAA);
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);
}
void loop() {
  val8 = digitalRead(cuc);
  if (val8 == HIGH) {
    Speech.write(0xAA);
    Speech.write(0x37);
    delay(2000);
    Speech.write(0xAA);
    Speech.write(0x22);
    delay(2000);
  }
  if (g2==0x22){
    
  }
  
 if (Speech.available())
  {
    com = Speech.read();
    switch (com) {
      case 0x11:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val1 = digitalRead(cuc);
        if (val1 == LOW) {
          digitalWrite(cuc, HIGH);
          Serial.print("luci cucina ");
          Serial.println("  pin 12 HIGH");
        }
        else {
          digitalWrite(cuc, LOW);
          Serial.print("cucina  spenta");
          Serial.println(" pin 12 low");
        }
        break;
      case 0x12://stanza uno(byte lettura18)
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val8 = digitalRead(uno);
        if (val8 == LOW) {
          digitalWrite(uno, HIGH);
          Serial.print("luci   accese");
          Serial.println(" pin 11 alto");
        }
        else {
          digitalWrite(uno, LOW);
          Serial.print("led spento");
          Serial.println(" pin 11 basso");
        }
        break;
      case 0x13:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val3 = digitalRead(due);
        Serial.print(" stanza accesa");
        Serial.println(" pin 10 alto");
        if (val3 == LOW) {
          digitalWrite(due, HIGH);
        }
        else {
          digitalWrite(due, LOW);
          Serial.print("stanza spenta");
          Serial.println(" pin 10 basso");
        }
        break;
        case 0x14:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val4 = digitalRead(por);
        if (val4 == LOW) {
          digitalWrite(por, HIGH);
          Serial.println("port");
        }
        else {
          digitalWrite(por, LOW);
        }
      case 0x15:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(cal);
        if (val5 == LOW) {
          digitalWrite(cal, HIGH);
          Serial.println("Caldaia accesa");
        }
        else {
          digitalWrite(cal, LOW);
        }
        break;
      case 0x16://clima
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(cli);
        if (val5 == LOW) {
          digitalWrite(cli, HIGH);
          Serial.println("Clima acceso");
          Serial.println(com);
        }
        else {
          digitalWrite(cli, LOW);
        }
       break;
    }
  }
}

Giorno ho provato ha riscrivere nuovamente ma debbo lavorarci ancora su,pero sembra che un passo avanti lo abbia fatto.Adesso se val8 è alta si ferma li e non prosegue debbo capire perchè,se bassa prosegue normale.Questo è il nuovo codice

[code]
#include <SoftwareSerial.h>
int cuc = 12;
int uno = 11;
int due = 10;
int por = 9;
int cal = 8;
int cli = 13;
//-------------------------
int val1 = 0;
int val2 = 0;
int val3 = 0;
int val4 = 0;
int val5 = 0;
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
int g1=0x21;
int g2=0x22;
byte com = 0;
SoftwareSerial Speech(5, 6); // RX, TX
void setup()
{
  Serial.begin(9600);
  Speech.begin(9600);
  pinMode(cli, OUTPUT);//inserito causa accensione fievole del led
  pinMode(cuc, OUTPUT);
  pinMode(uno, OUTPUT);
  pinMode(due, OUTPUT);
  pinMode(por, OUTPUT);
  pinMode(cal, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Speech.write(0xAA);
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);
}
void loop() {
  val8 = digitalRead(cuc);
  if (val8 == HIGH) {
    Speech.write(0xAA);
    Speech.write(0x37);
    delay(2000);
    Speech.write(0xAA);
    Speech.write(0x22);
    delay(2000);
     }
    //______________
    if (Speech.available())
  {
    com = Speech.read();
    switch (com) {
      case 0x11:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val1 = digitalRead(cuc);
        if (val1 == LOW) {
          digitalWrite(cuc, HIGH);
          Serial.print(" cucina ");
          Serial.println("  pin 12 HIGH");
        }
        else {
          digitalWrite(cuc, LOW);
          Serial.print("cucina  spenta");
          Serial.println(" pin 12 low");
        }
        break;
      case 0x12://stanza uno(byte lettura18)
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val8 = digitalRead(uno);
        if (val8 == LOW) {
          digitalWrite(uno, HIGH);
          Serial.print("luci   accese");
          Serial.println(" pin 11 alto");
        }
        else {
          digitalWrite(uno, LOW);
          Serial.print("led spento");
          Serial.println(" pin 11 basso");
        }
        break;
    }
  }
 
  if (g2==0x22){
    //_________________
  //}
  
 if (Speech.available())
  {
    com = Speech.read();
    switch (com) {
      case 0x11:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val1 = digitalRead(cuc);
        if (val1 == LOW) {
          digitalWrite(cuc, HIGH);
          Serial.print("luci cucina ");
          Serial.println("  pin 12 HIGH");
        }
        else {
          digitalWrite(cuc, LOW);
          Serial.print("cucina  spenta");
          Serial.println(" pin 12 low");
        }
        break;
      case 0x12://stanza uno(byte lettura18)
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val8 = digitalRead(uno);
        if (val8 == LOW) {
          digitalWrite(uno, HIGH);
          Serial.print("luci   accese");
          Serial.println(" pin 11 alto");
        }
        else {
          digitalWrite(uno, LOW);
          Serial.print("led spento");
          Serial.println(" pin 11 basso");
        }
        break;
      case 0x13:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val3 = digitalRead(due);
        Serial.print(" stanza accesa");
        Serial.println(" pin 10 alto");
        if (val3 == LOW) {
          digitalWrite(due, HIGH);
        }
        else {
          digitalWrite(due, LOW);
          Serial.print("stanza spenta");
          Serial.println(" pin 10 basso");
        }
        break;
        case 0x14:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val4 = digitalRead(por);
        if (val4 == LOW) {
          digitalWrite(por, HIGH);
          Serial.println("port");
        }
        else {
          digitalWrite(por, LOW);
        }
      case 0x15:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(cal);
        if (val5 == LOW) {
          digitalWrite(cal, HIGH);
          Serial.println("Caldaia accesa");
        }
        else {
          digitalWrite(cal, LOW);
        }
        break;
      case 0x16://clima
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(cli);
        if (val5 == LOW) {
          digitalWrite(cli, HIGH);
          Serial.println("Clima acceso");
          Serial.println(com);
        }
        else {
          digitalWrite(cli, LOW);
        }
       break;
    }
  }
}

}

[/code]

Intanto posta (copia/incolla sempre nei tag "code") cosa scrive sul monitor seriale quando fai girare il programma.

Ma devi anche spiegare meglio cosa pensi che debba fare, ossia il processo, perché perché dal codice non si capisce...

Ad esempio vedo che leggi il pin 12 (cucina) e lo memorizzi in val8 (ma si possono evitare sti nomi che non significano nulla?) poi vedi è HIGH e se lo è imposti il gruppo 2. Intanto questo lo fai continuamente finché è HIGH mentre (immagino) dovresti farlo solo quando passa da LOW a HIGH, una sola volta!

In ogni caso poi vedi se ricevi un comando speech, se è 0x11 leggi un'altra volta dal pin 12 (perché?) e lo metti in val1 (?) quindi se è LOW lo metti HIGH altrimenti lo metti LOW (quindi inverti ed è ok).

Diciamo quindi che lo metti HIGH, a quel punto il loop() entra nella prima if() e imposta il gruppo 2. A quel punto che deve fare?

Insomma, prova a descrivere le cose che dovrebbe leggere o fare, e mettile poi come se fossero dei commenti al codice quindi strutturati ad esempio:

// Leggi lo stato del pin cucina
// se è alto
  // Imposta Gruppo 2
// Leggi dalla scheda speech
  // Se ricevo il comando 0x11
    // Inverti il valore del pin cucina
  // Se ricevo il comando 0x12
    // ... eccetera

A quel punto potrei avere la traccia per inserire sotto ad ogni commento tutte le istruzioni che realizzano la cosa descritta.

E' ancora un casino ma sembra incominciare a rispondere ai comandi, solo che è un po troppo lento debbo ancora capire il perché. Il nuovo codice è questo vedi i casini che ho fatto.

[code]
#include <SoftwareSerial.h>
int pin1 = 12;
int pin2 = 11;
int pin3 = 10;
int pin4 = 9;
int pin5 = 8;
int pin6 = 13;
//-------------------------
int val1 = 0;
int val2 = 0;
int val3 = 0;
int val4 = 0;
int val5 = 0;
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
int g1 = 0x21;
int g2 = 0x22;
byte com = 0;
SoftwareSerial Speech(5, 6); // RX, TX
bool onetime = true;
void setup()

{
  Serial.begin(9600);
  Speech.begin(9600);
  pinMode(pin1, OUTPUT);//inserito causa accensione fievole del led
  pinMode(pin2, OUTPUT);
  pinMode(pin3, OUTPUT);
  pinMode(pin4, OUTPUT);
  pinMode(pin5, OUTPUT);
  pinMode(pin6, OUTPUT);
  pinMode(5, INPUT);//RX
  pinMode(6, OUTPUT); //TX
  delay(2000);
  Speech.write(0xAA);
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);
}
void loop() {
  val8 = digitalRead(pin1);
  if (val8 == HIGH)
    if (onetime)
    {
      Speech.write(0xAA);
      Speech.write(0x37);
      delay(2000);
      Speech.write(0xAA);
      Speech.write(0x22);
      delay(2000);
    }
  //______________
  if (Speech.available())
  {
    com = Speech.read();
    switch (com) {
      case 0x11:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        Serial.print(com, DEC);
        val1 = digitalRead(pin6);
        if (val1 == LOW) {
          digitalWrite(pin6, HIGH);
          Serial.print(" case11g2IGH ");

        }
        else {
          digitalWrite(pin6, LOW);
          Serial.print("case11g2LOW");
          onetime = false;
        }
        break;
      case 0x12:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val8 = digitalRead(pin2);
        if (val8 == LOW) {
          digitalWrite(pin2, HIGH);
          Serial.print("case12g2IGH");

        }
        else {
          digitalWrite(pin2, LOW);
          Serial.print("case12g2OW");
        }
        break;
    }
  }

  //
  //_________________
  //}

  if (Speech.available())
  {
    com = Speech.read();
    switch (com) {
      case 0x11:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val1 = digitalRead(pin1);
        if (val1 == LOW) {
          digitalWrite(pin1, HIGH);
          Serial.print("case11 g1HIGH ");
        }
        else {
          digitalWrite(pin1, LOW);
          Serial.println(" case11 g2 low");
        }
        break;
      case 0x12:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val8 = digitalRead(pin2);
        if (val8 == LOW) {
          digitalWrite(pin2, HIGH);
          Serial.print("case12 HIGH");
        }
        else {
          digitalWrite(pin2, LOW);
          Serial.print("case12 g1LOW");
        }
        break;
      case 0x13:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val3 = digitalRead(pin3);
        Serial.print(" case 13 g1 HIGH");
        if (val3 == LOW) {
          digitalWrite(pin3, HIGH);
        }
        else {
          digitalWrite(pin3, LOW);
          Serial.print("case12 g1 LOW");

        }
        break;
      case 0x14:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        val4 = digitalRead(pin4);
        if (val4 == LOW) {
          digitalWrite(pin4, HIGH);
          Serial.println("case13 g1 high");
        }
        else {
          digitalWrite(pin4, LOW);
        }
      case 0x15:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(pin5);
        if (val5 == LOW) {
          digitalWrite(pin5, HIGH);
          Serial.println("case15 g1 HIGH");
        }
        else {
          digitalWrite(pin5, LOW);
          Serial.println("case15 G1 LOW");
        }
        break;
      case 0x16:
        Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        val5 = digitalRead(pin6);
        if (val5 == LOW) {
          digitalWrite(pin6, HIGH);
          Serial.println("Case16 g2 HIGH");
        }
        else {
          digitalWrite(pin6, LOW);
          Serial.print ("case16 LOW");
        }
        break;
    }
  }
}

[/code]

Salve allora ho registrato tutto da capo e riscritto nuovamente il codice ,ma non ci sono stati cambiamenti,ti allego la visualizzazione del M.S. I primi cinque byte ricevuti si riferiscono al gruppo uno gli altri sono valori usciti pronunciando comandi (in sequenza )degli altri due gruppi .

17
Ricevuto byte 11
18
Ricevuto byte 12
19
Ricevuto byte 13
20
Ricevuto byte 14
21
Ricevuto byte 15
21
Ricevuto byte 15
21
Ricevuto byte 15
20
Ricevuto byte 14
19
Ricevuto byte 13
Ricevuto byte 13
20
Ricevuto byte 14
20
Ricevuto byte 14

il codice è:

#include <SoftwareSerial.h>


SoftwareSerial Speech(5, 6); // RX, TX
int ledPin = 12;//uscita digitale  pin 12
int redPin = 11; // uscita digitale  pin 11
int greenPin = 10; // uscita digitale  pin 10
int bbPin = 9;//uscita digitale  pin9
int bluePin = 8; // uscita digitale  pin 8
int apin = 13;
int bpin = 7;
int cpin = 4;
int dpin = 3;
int epin = 2;
//-------------------------
int val1 = 0; // iniziazzione della variabile e resa uguale a zero
int val2 = 0; // variabile per memorizzare il valore letto
int val3 = 0; // variabile per memorizzare il valore letto
int val4 = 0; // variabile per memorizzare il valore letto
int val5 = 0; // variabile per memorizzare il valore letto
int val6 = 0;
int val7 = 0;
int val8 = 0;
int val9 = 0;
byte com = 0; //reply from voice recognition

void setup()
{
  Serial.begin(9600);
  Speech.begin(9600);
    pinMode(ledPin, OUTPUT); 
  pinMode(redPin, OUTPUT); 
  pinMode(greenPin, OUTPUT); // sets the greenPin to be an output
  pinMode(bluePin, OUTPUT); // sets the bluePin to be an output
  pinMode(bbPin, OUTPUT);
  pinMode(apin, OUTPUT);
  pinMode(bpin, OUTPUT);
  pinMode(cpin, OUTPUT);
  pinMode(dpin, OUTPUT);
  pinMode(epin, OUTPUT);
  delay(2000);
  Speech.write(0xAA);      
  Speech.write(0x37);
  delay(1000);
  Speech.write(0xAA);
  Speech.write(0x21);     


}

void loop() 
{
  while (Speech.available())
  {
    com = Speech.read();
    Serial.println(com);
    switch (com)
    {

                  case 0x11:
        val1 = digitalRead(ledPin);
        if (val1 == LOW) {
          digitalWrite(ledPin, HIGH);
           Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(ledPin, LOW);
          Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
       
        }
        break;
      
      case 0x12:
        val2 = digitalRead(redPin);
        if (val2 == LOW) {
          digitalWrite(redPin, HIGH);
           Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        
        }
        else {
          digitalWrite(redPin, LOW);
           Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        
        }

        break;
    
      case 0x13:
        val3 = digitalRead(greenPin);
         Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
      
        if (val3 == LOW) {
          digitalWrite(greenPin, HIGH);
        }
        else {
          digitalWrite(greenPin, LOW);
           Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        
        }
        break;
      
      case 0x14:
        {
          digitalWrite(bbPin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
          delay(2000);               
          digitalWrite(bbPin, LOW);   
        }
        break;
      
      case 0x15:
        val5 = digitalRead(bluePin);
        if (val5 == LOW) {
          digitalWrite(bluePin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(bluePin, LOW);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);

        }
        break;
      
      case 0x16://red
        val5 = digitalRead(apin);
        if (val5 == LOW) {
          digitalWrite(apin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(apin, LOW);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        break;
      
      case 0x17://black
        val5 = digitalRead(bpin);
        if (val5 == LOW) {
          digitalWrite(bpin, HIGH);
             Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(bpin, LOW);
             Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        break;
      
      case 0x18:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(cpin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(cpin, LOW);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        break;
      
      case 0x19:
        val5 = digitalRead(dpin);
        if (val5 == LOW) {
          digitalWrite(dpin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(dpin, LOW);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        break;

    
      case 0x20:
        val5 = digitalRead(epin);
        if (val5 == LOW) {
          digitalWrite(epin, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(epin, LOW);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        break;
     
      case 0x21:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(8, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(8, LOW);
        }
        break;
      
      case 0x22:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(8, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(8, LOW);
        }
        break;
      
      case 0x23:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(8, HIGH);
             Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(8, LOW);
        }
        break;
      
      case 0x24:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(8, HIGH);
             Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(8, LOW);
        }
        break;
      
      case 0x25:
        val5 = digitalRead(8);
        if (val5 == LOW) {
          digitalWrite(8, HIGH);
              Serial.print("Ricevuto byte ");
        Serial.println(com, HEX);
        }
        else {
          digitalWrite(8, LOW);
        }
        break;
        
    }
  }
}