6 Arduini UNO che comunicano un float a un MEGA 2560 con SoftwareSerial

[Etemenanki]

... sappiamo che siete tutti bravissimi ...

Gli altri di sicuro, ma io proprio no XD ... ricordati che sono un'hardwarista, non un softwarista

[gpb01]

Gli altri di sicuro, ma io proprio no XD ... ricordati che sono un'hardwarista, non un softwarista

XD Dai, dai, non fare il modesto ... che hai la tua gran bella esperienza

Guglielmo

[Marcobz]

Aggiornamento:

tra le mie mille ricerche mi è capitata in mano una libreria chiamata EasyTransfer. Me la sono studiata un pò e ho provato a mettere giù uno sketch  per le mie esigenze.
Ecco il risultato:

PARTE TRASMITTENTE

Code: [Select]

#include <SoftEasyTransfer.h>  //includo la libreria ET
#include <SoftwareSerial.h>    //includo la libreria SS
SoftwareSerial mySerial(10, 11); //definisco le porte della SS
SoftEasyTransfer ET;              //creo l'oggetto ET

struct SEND_DATA_STRUCTURE{        //creo la struttura della serie di dati
  float valore1;                   //definisco quali variabili devono far parte della struttura
  float valore2;
};
SEND_DATA_STRUCTURE mydata;        //do un nome al gruppo di variabili

float valore1=20.97;               //dichiaro le variabili
float valore2=19.88;

void setup(){
  mySerial.begin(9600);            //faccio partire la SS
  ET.begin(details(mydata), &mySerial);  //faccio partire la ET
  Serial.begin(9600);                    //faccio partire la seriale 
}
void loop(){
  mydata.valore1 = valore1;        //do un valore alle variabili con la struttura [nome del gruppo].[nome della variabile]
  mydata.valore2 = valore2;        //do un valore alle variabili con la struttura [nome del gruppo].[nome della variabile]
  Serial.println(valore1);
  Serial.println(valore2);
  ET.sendData();//invio i dati
  delay(1000);
}

Ho provato a commentare le righe per far capire come funziona.

PARTE RICEVENTE

Code: [Select]

#include <SoftEasyTransfer.h>  //includo la libreria ET
#include <SoftwareSerial.h>    //includo la libreria SS
SoftwareSerial mySerial(10, 11); //definisco le porte della SS
SoftEasyTransfer ET;              //creo l'oggetto ET

struct RECEIVE_DATA_STRUCTURE{    //creo la struttura
  float valore1;                  //stesse variabili del TX
  float valore2;
};
float valore1;                    //le dichiaro
float valore2;                    //le dichiaro
RECEIVE_DATA_STRUCTURE mydata;     //do lo stesso nome del TX alla struttura

void setup(){
  mySerial.begin(9600);            //faccio partire la SS
  ET.begin(details(mydata), &mySerial);  //faccio partire la ET
  Serial.begin(9600);                    //faccio partire la seriale 
}

void loop(){
  if(ET.receiveData()){        //controllo se è arrivato un pacchetto di dati
  valore1 = mydata.valore1;    //assegno i valori ricevuti alle variabili
  valore2 = mydata.valore2;
  Serial.println(valore1);     //le stampo
  Serial.println(valore2);
    }
  delay(250); //fortemente consigliato per non perdere pezzi del messaggio ricevuto
}

So che Guglielmo storcerà il naso.. Però FUNZIONA !!!
Tral l'altro da quello che ho capito ci sono diverse versioni della libreria. Questa _{SoftEasyTransfer} nello specifico credo sia dedicata alle comunicazioni su seriale software (che poi è quello che mi serve).
Dal puro lato didattico non è il massimo.. lo so.. però per quanto mi riguarda non è che adesso smetto di cercare di imparare quello di cui si stava qui discutendo !

[gpb01]

Bene, contento tu ...   ]

... così non impari nulla e la prima volta che quella lib non ti funzionerà o, un giorno magari non sarà più supportata ... sarai da capo a dodici.

Ma ripeto ... contento tu ... contenti tutti !!! 

Guglielmo

[Marcobz]

No non mi fraintendere !
Ho anche detto che il discorso affrontato fino a qui lo vorrei continuare ! Ovviamente se le parti sono interessate.... io lo sono !

[gpb01]

Ho anche detto che il discorso affrontato fino a qui lo vorrei continuare ! Ovviamente se le parti sono interessate.... io lo sono !

Ok, allora metti l'ultima versione a cui sei arrivato e dimmi che problemi ti da ... che riprendiamo da li ...

Guglielmo

[Maurotec]

Io non conosco nel dettaglio la SoftEasyTransfer, però da quello che vedo nel codice che hai postato mi sembra una libreria ben fatta. Più o meno è quello che dicevo nel mio post precedente riguardo alle struct usate come payload.

Preferisco questo del payload per vari motivi:
1) La classe o funzione che spedisce i dati è generica e non legata ad un tipo utente, ma richiede semplicemente un puntatore a byte e la lunghezza del payload in byte.
2) I dati da spedire sono messi in ordine e ricevuti nello stesso ordine in modo automatico grazie alla condivisione della struct.
3) La classe può essere personalizzata aggiungendo dei metodi setStartCode(int code) e setEndCode(int code)
questo permette al ricevente di scegliere il tipo di collezione di dati.
Un tipo di collezione di dati potrebbe essere:
- Dati di configurazione (code = 1)
- Dati di aggiornamento (code = 2)
- Dati di instradamento (code = 3)
- Dati di configurazione remota (code = 4)

In ricezione basta uno switch case startCode per ricevere dati e usarli in modo specifico, modo stabilito dal trasmittente.

@gpb01
Di soluzioni a problemi conosciuti (design pattern) ce n'è più di una, basta conoscerle tutte e scegliere quella che
preferiamo, questa del payload è una, le altre suggerite con tutte le varianti e quelle a venire sono tutte da scoprire.

Ciao.

[Marcobz]

Eccomi qua !

Scusa l'assenza Guglielmo ma è un periodo "pregno" 

Ho adattato lo sketch al mio caso

Code: [Select]

#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11);


#define MAXCHAR  10
#define TERCHAR  0x0D

char inputString[MAXCHAR + 2];
char inChar;
byte strIndex;


void setup() {
 
  strIndex = 0;
  inputString[strIndex] = 0x00;
  mySerial.begin(9600);
  Serial.begin(9600);
 
}

void loop() {
 
  if (mySerial.available()) {
    inChar = mySerial.read();
    // se si vogliono vedere in HEX i caratteri che si ricevono
    // togliere il commento alla riga seguente
    // Serial.println(inChar, HEX);
    if (inChar == (char) TERCHAR) {
      // è arrivato il carattere terminatore, si puo' elaborare la stringa
      // In questo esempio semplicemente la si stampa ...
      Serial.print(F("Input string : "));
      Serial.println(inputString);
      //
      // finito il suo uso la si ripulisce per un uso successivo
      strIndex = 0;
      inputString[strIndex] = 0x00;
    }
    // NON è arrivato il carattere terminatore, si memorizza il carattere ricevuto
    // e si sposta il fine stringa ...
    inputString[strIndex] = inChar;
    strIndex++;
    inputString[strIndex] = 0x00;
    if (strIndex > MAXCHAR + 1) {
      // ... NON c'è pi` spazio nella stringa ... bisogna elaborarla e svuotarla
      // In questo esempio semplicemente la si stampa ...
      Serial.print(F("Overflow string : "));
      Serial.println(inputString);
      delay(5);
      Serial.print(F("More chars : "));
      Serial.println(Serial.available());
      // Butta via i caratteri che erano rimasti nel buffer della seriale ...
      while (mySerial.available()) {
          delay(5);
          mySerial.read();
      }
      //
      // e ripulisce la stringa per un uso successivo
      strIndex = 0;
      inputString[strIndex] = 0x00;
    }
  }
}


e questo è il risultato

Code: [Select]

Overflow string : þ29.571329.5
More chars : 0

Che ne dici se commentiamo ogni riga a scopo esplicativo per chi vuole capire ? Tipo io ?  XD

[gpb01]

Allora,
primo ... occhio che non hai sostituito una Serial :

Code: [Select]

Serial.print(F("More chars : "));
Serial.println(Serial.available());

deve diventare :

Code: [Select]

Serial.print(F("More chars : "));
Serial.println(mySerial.available());

perché stiamo vedendo quanti caratteri ci sono ancora nel buffer della SoftwareSerial.

Poi ...
... ma ti da solo quello   Ovvero se lasci girare il tutto per 30 secondi ... cosa succede ... hai tutte le ricezioni errate

O capita ogni tanto ...

Guglielmo