Pages: [1] 2   Go Down
Author Topic: Domande Basilari Su Come Leggere Dati da 2 Sensori  (Read 2378 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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  smiley-lol

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)
Code:
/*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:



Code:
/*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 smiley-cry
Logged

Marche
Offline Offline
Edison Member
*
Karma: 34
Posts: 2276
azioni semplici per risultati complessi
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Intanto BENVENUTO!

Vedo una cosa: stai usando le stesse variabili per entrambi i sensori
Code:
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.
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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:
Code:
/*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.
      }
    }
  }
}
  }
    }
  }

Logged

Selvazzano Dentro - Padova
Offline Offline
Edison Member
*
Karma: 45
Posts: 1553
"Chi sa fa, chi non sa insegna"
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Code:

  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)
      {
    {
  {

Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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...
Logged

Marche
Offline Offline
Edison Member
*
Karma: 34
Posts: 2276
azioni semplici per risultati complessi
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Code:
/*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.
      }
    }
  }
}
Logged

Selvazzano Dentro - Padova
Offline Offline
Edison Member
*
Karma: 45
Posts: 1553
"Chi sa fa, chi non sa insegna"
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Code:
#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.
}

Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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'? smiley-eek-blue
Logged

Selvazzano Dentro - Padova
Offline Offline
Edison Member
*
Karma: 45
Posts: 1553
"Chi sa fa, chi non sa insegna"
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

E certo che non ti funziona!

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

Code:
...
      if (CHKS == lowByte(0xFF + Hdata + Ldata)) {
...
« Last Edit: August 04, 2012, 06:33:54 pm by cyberhs » Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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?
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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

Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ragazzi ho scoperto cosa fa sclerare tutto

Code:
#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

Code:
#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.
}

Logged

Selvazzano Dentro - Padova
Offline Offline
Edison Member
*
Karma: 45
Posts: 1553
"Chi sa fa, chi non sa insegna"
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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!! smiley-cry
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 15
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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?
Logged

Pages: [1] 2   Go Up
Jump to: