Go Down

Topic: Voice recognize geeetech (Read 989 times) previous topic - next topic

Etabeta2018

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?
Code: [Select]
[/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]

docdoc

#1
Jun 12, 2018, 11:03 am Last Edit: Jun 12, 2018, 11:05 am by docdoc
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? :)
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Etabeta2018

#2
Jun 12, 2018, 07:54 pm Last Edit: Jun 13, 2018, 06:47 am by Etabeta2018
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.

gpb01

#3
Jun 12, 2018, 08:02 pm Last Edit: Jun 12, 2018, 08:02 pm by gpb01
>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
Search is Your friend ... or I am Your enemy !

Etabeta2018

#4
Jun 12, 2018, 09:51 pm Last Edit: Jun 12, 2018, 09:56 pm by Etabeta2018
Ok chiedo scusa ho provveduto.
Code: [Select]
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;
        }
    }
  }
}

docdoc

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:

Code: [Select]
  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.


Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Etabeta2018

#6
Jun 13, 2018, 09:02 pm Last Edit: Jun 13, 2018, 09:17 pm by Etabeta2018
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

 
Code: [Select]
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;
        }
    }
  }

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

docdoc

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:

Code: [Select]
  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:

Code: [Select]
void invia(byte valore) {
  Serial1.write(valore);
  Serial.print(valore, HEX);
  Serial.print(" ");
}


Prova e facci sapere!
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Etabeta2018

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

Etabeta2018

#9
Jun 14, 2018, 09:55 pm Last Edit: Jun 14, 2018, 09:57 pm by 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 ,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.
Code: [Select]
#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;
        }
    }
  }
}
//---------------------

docdoc

#10
Jun 15, 2018, 02:11 pm Last Edit: Jun 15, 2018, 02:37 pm by docdoc
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!
Code: [Select]

  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ù... ;)

4) 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:

Code: [Select]
#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;
        }
    }
  }
}
//---------------------


Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Etabeta2018

#11
Jun 15, 2018, 10:02 pm Last Edit: Jun 15, 2018, 10:37 pm by Etabeta2018
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

Code: [Select]
#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;
        }
    }
  }


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


docdoc

#12
Jun 18, 2018, 10:19 am Last Edit: Jun 18, 2018, 10:20 am by docdoc
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.

Quote
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().

Quote
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:

Code: [Select]
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
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Etabeta2018

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

docdoc

#14
Jun 20, 2018, 01:28 pm Last Edit: Jun 20, 2018, 01:35 pm by docdoc
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.
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Go Up