Domande Basilari Su Come Leggere Dati da 2 Sensori

Salve a tutti, Come capirete da questo post sono totalmente alle prime armi nella programmazione di arduino, lo uso molto tramite Max e normalmente quando mi sono trovato a programmare direttamente lui mi sono basato su libri e cercando conversazioni su vari forum.
Il Problema e’ che questa cosa e’ talmente basilare che non riesco a trovarla da nessuna parte…
Ho comprato 2 sensori DYP ME007TX che sono sensori di prossimita, volevo leggerne il valore e con Max creare una specie di Theremin.
Grazie a questo articolo http://arduino.cc/forum/index.php?topic=69100.15 sono riuscito ad ottenere un input seriale riguardo alla distanza e ad utilizzarlo con Max… magnifico; il problema e’ che a me serve leggere 2 sensori, ho provato in vari modi ma non ci riesco!!!
Un sensore e’ collegato sul pin digitale 3, il secondo sul 5.
Chiedo Umilmente aiuto!!! posto anche uno sketch contenente un mio tentativo fallito di risoluzione del problema, cosi’ da sorbirmi costruttivi insulti XD

Questo e’ lo sketch funzionante che mi restituisce un valore riguardo alla distanza in cm dal sensore. Il seriale che rientra ha la tag “distanza cm” a me interessava ottenere 2 valori da 2 sensori, (distanza1 cm) (distanza 2 cm)

/*sketch di lettura dei dati dal sensore DYP-ME007TX, sensore ad ultrasuoni che trasmette i dati direttamente
 in seriale utilizzando lo schema
 1st Byte : 0xFF (Start bit, Fixed value)
 2ed Byte: H_Data (High 8 bit of the distance)
 3rd Byte: L_Date (Low 8 bit of the distance)
 4th Byte: Check Sum (0XFF+H_DATA+L_DATA=SUM, Check SUM is the low 8 bit of the SUM)
 Dal datasheet sappiamo che il sensore completa il ciclo di invio di 4 byte in 50ms.
 */
#include <SoftwareSerial.h> //usiamo la libreria NewSoftSerial, ci permetterà di creare 
//una porta seriale usando due pin digitali qualsiasi di arduino.

SoftwareSerial mySerial(3, 4); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 

byte BITSTART = 0;
byte Hdata = 0;              //inizializziamo le variabili necassarie, 
byte Ldata = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS = 0;                //sono le letture che più ci interessano perchè
byte temp = 0;               //contengono la distanza.


void setup() {
  Serial.begin(9600);        //inizializziamo la porta seriale di arduino per ricevere i dati a 9600bps
  mySerial.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps

}
void loop() {
  if (mySerial.available() >= 4){  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART = temp;
      Hdata = mySerial.read();  //continua la lettura e assegna alle
      Ldata = mySerial.read();  //variabili le letture successive.
      CHKS = mySerial.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

        unsigned int SUM = (BITSTART + Hdata + Ldata); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS) {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
                                                        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
      }
    }
  }
}

Mentre Quest’ altro e’ stato il mio tentativo fallimentare di risoluzione del problema, compila ma da arduino non ritorna nulla:

/*sketch di lettura dei dati dal sensore DYP-ME007TX, sensore ad ultrasuoni che trasmette i dati direttamente
 in seriale utilizzando lo schema
 1st Byte : 0xFF (Start bit, Fixed value)
 2ed Byte: H_Data (High 8 bit of the distance)
 3rd Byte: L_Date (Low 8 bit of the distance)
 4th Byte: Check Sum (0XFF+H_DATA+L_DATA=SUM, Check SUM is the low 8 bit of the SUM)
 Dal datasheet sappiamo che il sensore completa il ciclo di invio di 4 byte in 50ms.
 */
#include <SoftwareSerial.h> //usiamo la libreria NewSoftSerial, ci permetterà di creare 
//una porta seriale usando due pin digitali qualsiasi di arduino.

SoftwareSerial mySerial(3, 4); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 
SoftwareSerial mySerial2(5, 6); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 

byte BITSTART = 0;
byte Hdata = 0;              //inizializziamo le variabili necassarie, 
byte Ldata = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS = 0;                //sono le letture che più ci interessano perchè
byte temp = 0;               //contengono la distanza.


void setup() {
  Serial.begin(9600);        //inizializziamo la porta seriale di arduino per ricevere i dati a 9600bps
  mySerial.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
 mySerial2.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
}
void loop() {
  if (mySerial.available() >= 4){  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART = temp;
      Hdata = mySerial.read();  //continua la lettura e assegna alle
      Ldata = mySerial.read();  //variabili le letture successive.
      CHKS = mySerial.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

        unsigned int SUM = (BITSTART + Hdata + Ldata); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS) {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
                                                        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
    
  if (mySerial2.available() >= 4){  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial2.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART = temp;
      Hdata = mySerial2.read();  //continua la lettura e assegna alle
      Ldata = mySerial2.read();  //variabili le letture successive.
      CHKS = mySerial2.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial2.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

        unsigned int SUM = (BITSTART + Hdata + Ldata); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS) {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
                                                        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza2 (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
      }
    }
  }
}
  }
    }
  }

Vi Ringrazio in anticipo per l’aiuto =(

Intanto BENVENUTO!

Vedo una cosa: stai usando le stesse variabili per entrambi i sensori

byte BITSTART = 0;
byte Hdata = 0;              //inizializziamo le variabili necassarie, 
byte Ldata = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS = 0;                //sono le letture che più ci interessano perchè
byte temp = 0;               //contengono la distanza.

Prova aggiungendone altre riservate per il secondo sensore byte BITSTART2 = 0; byte Hdata2 = 0; //inizializziamo le variabili necassarie, byte Ldata2 = 0; //come da datasheet del sensore, Hdata e Ldata byte CHKS2 = 0; //sono le letture che più ci interessano perchè byte temp2 = 0; //contengono la distanza.

Ti Ringrazio, ho corretto ma niente, appena carico lo sketch si blocca proprio il flusso di dati e non torna piu’ indietro nulla da arduino.
Mah
Riposto Lo sketch Aggiornato:

/*sketch di lettura dei dati dal sensore DYP-ME007TX, sensore ad ultrasuoni che trasmette i dati direttamente
 in seriale utilizzando lo schema
 1st Byte : 0xFF (Start bit, Fixed value)
 2ed Byte: H_Data (High 8 bit of the distance)
 3rd Byte: L_Date (Low 8 bit of the distance)
 4th Byte: Check Sum (0XFF+H_DATA+L_DATA=SUM, Check SUM is the low 8 bit of the SUM)
 Dal datasheet sappiamo che il sensore completa il ciclo di invio di 4 byte in 50ms.
 */
#include <SoftwareSerial.h> //usiamo la libreria NewSoftSerial, ci permetterà di creare 
//una porta seriale usando due pin digitali qualsiasi di arduino.

SoftwareSerial mySerial(3, 4); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 
SoftwareSerial mySerial2(5, 6); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 

byte BITSTART = 0;
byte Hdata = 0;              //inizializziamo le variabili necassarie, 
byte Ldata = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS = 0;                //sono le letture che più ci interessano perchè
byte temp = 0;               //contengono la distanza.
byte BITSTART2 = 0;
byte Hdata2 = 0;              //inizializziamo le variabili necassarie, 
byte Ldata2 = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS2 = 0;                //sono le letture che più ci interessano perchè
byte temp2 = 0;               //contengono la distanza.


void setup() {
  Serial.begin(9600);        //inizializziamo la porta seriale di arduino per ricevere i dati a 9600bps
  mySerial.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
 mySerial2.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
}
void loop() {
  if (mySerial.available() >= 4){  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART = temp;
      Hdata = mySerial.read();  //continua la lettura e assegna alle
      Ldata = mySerial.read();  //variabili le letture successive.
      CHKS = mySerial.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

        unsigned int SUM = (BITSTART + Hdata + Ldata); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS) {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
                                                        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
    
  if (mySerial2.available() >= 4){  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial2.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART2 = temp;
      Hdata2 = mySerial2.read();  //continua la lettura e assegna alle
      Ldata2 = mySerial2.read();  //variabili le letture successive.
      CHKS2 = mySerial2.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial2.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

        unsigned int SUM = (BITSTART2 + Hdata2 + Ldata2); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS2) {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
                                                        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza2 (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
      }
    }
  }
}
  }
    }
  }

Credo che il problema sia relativo alla sincronizzazione dei dati in arrivo.

Non per niente i progettisti del dispositivo inviano all’inizio un byte di Start (0xFF), poi i due byte della misura ed infine un byte di Checksum.

Dovresti sincronizzarti sul byte di Start (ovviamente), salvo poi controllare che il Checksum sia esatto: infatti sia i byte della misura, sia il byte del Cheksum potrebbero contenere il valore 0xFF.

Ettore Massimo Albani

  if (mySerial.available() > 0) {
    if (mySerial.read()== 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == 0xFF + Hdata + Ldata) {
        misura = (Hdata << 8) | Ldata;
        Serial.println(misura, DEC)
      {
    {
  {

Grazie , ho provato a fare quello che mi hai detto ma niente non ricevo ancora nulla, ma può anche essere per il fatto che non l ho scritto in maniera corretta.... "come ho scritto sopra non sono una cima purtroppo " Se riesci a correggermi il codice completo mi faresti un favore... Scusa per la scocciatura...

Prova con questo, se funziona dai uno sguardo a cosa ho cambiato :wink:

/*sketch di lettura dei dati dal sensore DYP-ME007TX, sensore ad ultrasuoni che trasmette i dati direttamente
 in seriale utilizzando lo schema
 1st Byte : 0xFF (Start bit, Fixed value)
 2ed Byte: H_Data (High 8 bit of the distance)
 3rd Byte: L_Date (Low 8 bit of the distance)
 4th Byte: Check Sum (0XFF+H_DATA+L_DATA=SUM, Check SUM is the low 8 bit of the SUM)
 Dal datasheet sappiamo che il sensore completa il ciclo di invio di 4 byte in 50ms.
 */
#include <SoftwareSerial.h> //usiamo la libreria NewSoftSerial, ci permetterà di creare 
//una porta seriale usando due pin digitali qualsiasi di arduino.

SoftwareSerial mySerial(3, 4); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 
SoftwareSerial mySerial2(5, 6); //creiamo la nostra nuova porta seriale "mySerial" 
//e associamo 2 a RX e 3 a TX. 

byte BITSTART = 0;
byte Hdata = 0;              //inizializziamo le variabili necassarie, 
byte Ldata = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS = 0;                //sono le letture che più ci interessano perchè
byte temp = 0;               //contengono la distanza.
byte BITSTART2 = 0;
byte Hdata2 = 0;              //inizializziamo le variabili necassarie, 
byte Ldata2 = 0;              //come da datasheet del sensore, Hdata e Ldata
byte CHKS2 = 0;                //sono le letture che più ci interessano perchè
byte temp2 = 0;               //contengono la distanza.


void setup() 
{
  Serial.begin(9600);        //inizializziamo la porta seriale di arduino per ricevere i dati a 9600bps
  mySerial.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
  mySerial2.begin(9600);      //inizializziamo la seriale creata tramite la libreria newsoftserial a9600bps
}

void loop() 
{
  //Primo sensore
  if (mySerial.available() >= 4)
  {  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp = mySerial.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp==0xFF) 
    {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART = temp;
      Hdata = mySerial.read();  //continua la lettura e assegna alle
      Ldata = mySerial.read();  //variabili le letture successive.
      CHKS = mySerial.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura = Hdata << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura = misura | Ldata;            //uniamo Hdata e Ldata

      unsigned int SUM = (BITSTART + Hdata + Ldata); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM) == CHKS) 
      {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                             //rimani fermo per 5 secondi.
      }
    }
  }  
  //Secondo sensore
  if (mySerial2.available() >= 4)
  {  //verifichiamo che nel buffer seriale siano presenti i 4 byte mandati dal sensore
    temp2 = mySerial2.read();        //se si verifica la condizione leggiamo il primo byte e lo memorizziamo su temp
    if (temp2==0xFF) 
    {             //solo se leggiamo "0xFF" continuiamo la letture degli altri byte
      BITSTART2 = temp2;
      Hdata2 = mySerial2.read();  //continua la lettura e assegna alle
      Ldata2 = mySerial2.read();  //variabili le letture successive.
      CHKS2 = mySerial2.read();   //è il byte di checksum, da datasheet gli ultimi 8 bit della somma tra BITSTART, Hdata, Ldata.
      mySerial2.flush();         //svuotiamo il buffer della porta seriale per sicurezza

      unsigned int misura2 = Hdata2 << 8;   //facciamo un cast della misura e spostiamo verso sinistra di 8 posizioni il valore di Hdata(bit shifting).
      misura2 = misura2 | Ldata2;            //uniamo Hdata e Ldata

      unsigned int SUM2 = (BITSTART2 + Hdata2 + Ldata2); //sommiamo le tre variabili BITSTART + Hdata + Ldata e le immagazziniamo sull'intero SUM
      if (lowByte(SUM2) == CHKS2) 
      {                       //verifichiamo che gli 8 bit più a destra coincidano col valore della variabile CHKS
        //così verifichiamo che la trasmissione sia avvenuta senza errori.
        Serial.print("distanza2 (cm): ");       //stampa sul serial monitor il testo tra "".
        Serial.println(misura2/10);             //stampa il valore della variabile misura dividendola per 10, ovvero convertendola in centimetri.
        delay(10);                           //rimani fermo per 5 secondi.
      }
    }
  }
}
#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);
  mySerial2.begin(9600);
}

void loop() {

  if (mySerial.available() > 0) {
    if (mySerial.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial.read();     //continua la lettura e assegna alle
      Ldata = mySerial.read();     //variabili le letture successive.
      CHKS = mySerial.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == 0xFF + Hdata + Ldata) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura 1 cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  if (mySerial2.available() > 0) {
    if (mySerial2.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == 0xFF + Hdata + Ldata) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura 2 cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  delay(10);                             //rimani fermo per 5 secondi.
}

Prima di tutto vi ringrazio entrambi. A Cyberhs la patch non rimanda in dietro nulla non funziona. Mentre per Pelletta quasi ci siamo, mi tornano dati seriali solo di "distanza2" non mi tornano entrambi purtroppo, o provato a desincronizzare i ritardi ma niente, don ricevo piu' dati dal primo sensore... si riesce a capire perche'? :fearful:

E certo che non ti funziona!

Ho dimenticato di aggiungere la funzione lowByte() nel calcolo del CHKS!

...
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
...

Adesso Funziona ma mi da lo stesso problema dell altro, nel serial monitor mi tornano solo dati relativi al 2o sensore

Ho provato a desincronizzare i tempi di delay mettendo 30ms a uno e 20ms all'altro, ma nulla, ho provato a cambiare la frequenza di bit di uno portandola a 4800 lasciando a 9600 l'altra ma niente ancora....avete idea del perche' il primo ora viene totalmente bypassato?

Ho Provato a filtrare i segnali con Max e ho riavuto la conferma che non arriva nulla dal sensore 1…

Ragazzi ho scoperto cosa fa sclerare tutto

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

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

  mySerial.begin(9600);
   mySerial2.begin(9600);

mySerial2.begin se sta sotto a mySerial.begin ricevo segnali solo da myserial2 (misura2), se invece sta sopra ricevo solo da mySerial (misura1).
Per me e’ proprio un errore stupido del tipo che non posso far entrare 2 cose nella stessa porta.
Non c’e’ proprio nessuno che ci capisce qualcosa?

Allego Il codice Completo Su cui sto lavorando adesso

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

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

  mySerial.begin(9600);
   mySerial2.begin(9600);
  

}

void loop() {

  if (mySerial.available() > 0) {
    if (mySerial.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial.read();     //continua la lettura e assegna alle
      Ldata = mySerial.read();     //variabili le letture successive.
      CHKS = mySerial.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
           if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura1cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  if (mySerial2.available() > 0) {
    if (mySerial2.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
            if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura2cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  delay(10);                             //rimani fermo per 5 secondi.
}

Mi è venuto un dubbio.

Che IDE stai usando?

La libreria SoftwareSerial nella IDE 1.0.1 (la più recente) è derivata dalla NewSoftSerial che consente appunto istanze multiple, ma limitata dal fatto che solo un Rx alla volta viene gestito.

Quindi se hai precedenti versioni di IDE potrebbe essere quello il motivo.

Comunque, tra i due cicli è meglio inserire un piccolo ritardo per consentire al buffer di ricezione della seconda seriale di riempirsi.

Poiche vai a 9600 baud il ritardo dovrebbe essere almeno 5 ms (millis(5)), ma poiché non sappiamo la velocità di emissione del pacchetto dati, prova inizialmente a mettere millis(1000).

Ettore Massimo Albani

Ho installato l’ultima versione di arduino… ma nulla non va lo stesso… ho provato a caricare “two port receive”, dicendogli le porte che mi servono… e arrivano dati scritti in klingoniano ma arrivano da entrambi i sensori.
Pero’ se riesco ad applicare il mio sketch su quello dovrebbe funzionare … io ci provo, se riesco posto tutto, se no QUALCUNO MI AIUTI!! =(

Niente da fare, il codice e' completamente da riscrivere con due sensori , non funziona le ho provate tutte, potete aiutarmi a capire cosa non consente la lettura di entrambi i sensori?

Non mi interessa ottenere un valore in centimetri, mi interessa solo ottenere un valore riguardo la distanza da entrambi i sensori…

Prova con questo. Ho inserito i ritardi giusti ed un print per vedere se il buffer della seconda seriale si riempie.

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);
  mySerial2.begin(9600);
}

void loop() {

  if (mySerial.available() > 0) {
    if (mySerial.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial.read();     //continua la lettura e assegna alle
      Ldata = mySerial.read();     //variabili le letture successive.
      CHKS = mySerial.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura1cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  delay(50);                             // rimani fermo per 50 ms (tempo di ciclo del sensore)

  if (mySerial2.available() > 0) {
    Serial.print("Buffer ");
    Serial.println(mySerial2.available(), DEC);
    if (mySerial2.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura2cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  delay(50);                             // rimani fermo per 50 ms (tempo di ciclo del sensore)
}

niente ancora Ecco quello Che Succede con il tuo sketch:

http://www.themoogs.net/problema.mov

Trovato!

Il problema era semplice: come ti avevo detto, solo una porta alla volta può essere in ascolto (vedi esempio SoftwareSerial/TwoPortReceive).

Basta inserire l’istruzione mySerial.listen() prima del ciclo di interrogazione della prima porta e l’istruzione mySerial2.listen() prima di quello della seconda.

Mi sembrava impossibile che non funzionasse!

Ho eliminato i ritardi perché probabilmente non servono.

Ettore Massimo Albani

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);
  mySerial2.begin(9600);
}

void loop() {

  mySerial.listen();

  if (mySerial.available() > 0) {
    if (mySerial.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial.read();     //continua la lettura e assegna alle
      Ldata = mySerial.read();     //variabili le letture successive.
      CHKS = mySerial.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura1cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  

  mySerial2.listen();

  if (mySerial2.available() > 0) {
  
    if (mySerial2.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura2cm ");
        Serial.println(Misura / 10, DEC);
      }
    }
  }  
}

Purtroppo lo sketch che hai caricato non mi restituiva nessun valore, pero’ mi e’ stato di ispirazione e ho cominciato a giocarci
Sono riuscito a scorgere la fine del tunnel con Questo sketch:

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3, 4);
SoftwareSerial mySerial2(5, 6);

byte Hdata = 0; 
byte Ldata = 0;
byte CHKS = 0;
unsigned int Misura = 0;

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

  mySerial.begin(9600);
  mySerial2.begin(9600);
}

void loop() {

  if (mySerial.available() > 0) {
    if (mySerial.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial.read();     //continua la lettura e assegna alle
      Ldata = mySerial.read();     //variabili le letture successive.
      CHKS = mySerial.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
           if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
        Serial.print("Misura1cm ");
        Serial.println(Misura / 10, DEC);
      }
   
    }
  }  
    delay(10);                             //rimani fermo per 5 secondi.


  if (mySerial2.available() > 0) {
    if (mySerial2.read() == 0xFF) {    // potrebbe essere il carattere di Start
      Hdata = mySerial2.read();     //continua la lettura e assegna alle
      Ldata = mySerial2.read();     //variabili le letture successive.
      CHKS = mySerial2.read();      //è il byte di checksum, da datasheet gli ultimi 8 bit della somma 0xFF + Hdata + Ldata.
            if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
        Misura = (Hdata << 8) | Ldata;
          mySerial.listen();

        Serial.print("Misura2cm ");
        Serial.println(Misura / 10, DEC);
      }
    
    }
  }  

  delay(1000);                             //rimani fermo per 5 secondi.

}

Ho aggiunto mySerial.listen(); prima del Serial.print("Misura2cm "); e
SONO RIUSCITO AD OTTENERE QUESTO!!!

Mi ha restituito il valore di entrambi una sola volta! poi si e’ concentrato su uno solo!! Ci Siamo Quasi mi sa!!! io continuo a provare, ma se hai la soluzione postala!