Non ho capito bene qual'è l'obbiettivo, penso che si voglia inviare una valore numerico in virgola mobile
e riceverlo dall'altro lato.
Ci sono varie soluzioni, alcune semplici e altre meno, quale usare dipende dall'applicazione e cosa realmente ci aspettiamo di ricevere e dal dispositivo preposto a ricevere.
Se ho un numero, sul quale compio delle operazioni matematiche e voglio spedirlo via seriale al terminale di arduino
dovrei poter usare il metodo size_t Print::println(double num, int digits) che viene ereditato da Serial e quindi scrivere Serial.print(22.22, 4) dove:
@int digit dovrebbe essere il numero massimo di cifre dopo la virgola.
Ciò che viene spedito è una rappresentazione ASCII dei @double num e viene terminato da un carattere 'nl' (new line).
Chi riceve quindi opera con una collezione di caratteri ASCII che rappresentano un numero, sul quale non possiamo fare operazioni matematiche, ma siamo costretti a convertire il ricevuto in un numero e di questo dobbiamo sapere il tipo, cioè se float o intero.
Se invece vogliamo spedire numeri reali e ricevere numeri reali possiamo farlo ma ora il pranzo è pronto.
@gingardu
Il codice è complesso, poco flessibile e per niente elegante ed efficiente, con questo non vuol dire che è da buttare,
ma che devi valutare se procedere su questa strada o cercare una soluzione più elegante o meglio un pattern conosciuto e collaudato. Se decidi di procedere per la tua strada dovrai rendere il codice elegante, efficiente, semplice, flessibile ecc. e il percorso è lungo ma può dare soddisfazioni e inoltre si impara tanto, solo che poi ti renderai conto che gira e rigira sei arrivato alla soluzione a problemi già conosciuti detti appunto pattern, questo in fase di apprendimento è un percorso da lodare.
Qualunque oggetto informatico è composto da numeri binari, qualunque numero binario può essere inviato via seriale o altro mezzo di trasmissione. La dimensione più piccola che possiamo inviare attraverso la connessione seriale è il byte, cioè 8 bit. Un oggetto di qualunque tipo viene conservato in memoria, questa è composta da cella consecutive da un byte cd, pertanto qualunque oggetto può essere prelevato byte per byte e inviato alla seriale un numero totale di volte tanto quanto è grande l'oggetto.
Il metodo: size_t Print::write(const uint8_t *buffer, size_t size) viene ereditato pubblicamente dalla classe Serial, pertanto lo si può usare per spedire qualunque oggetto via seriale. Posso anche spedire un oggetto di classe utente, cioè una istanza di una mia classe.
Es: Dbase myDbase;
myDbase è istanza oggetto di classe Dbase e pertanto posso spedirlo così:
Serial.write((uint8_t )&myDbase, sizeof(myDbase));
L'operazione di cast (uint8_t) è necessaria per trasformare il puntatore ad un oggetto myDbase a puntatore a byte.
Se sizeof(myObject) per qualche motivo non ritorna la dimensione reale, l'oggetto verrà: o spedito parzialmente o verranno spedite porzioni di memoria che non appartengono a myObject.
Ora se il ricevente colleziona in un buffer tutti i byte trasmessi correttamente sarà possibile ricostituire l'oggetto myObject che abbiamo inviato. Sarà sufficiente creare un puntatore Dbase myDbase = (Dbase)recvBuffer;
Quello che facciamo è fare il cast di un oggetto array di byte (cioè il buffer) a puntatore di classe Dbase.
Adesso se tutto è andato a buon fine posso usare myDbase. Attenzione che se Dbase ha membri puntatori ad oggetto esterni alla classe Dbase questi punteranno ad aree di memoria che avevano un senso per il trasmittente e non è detto che abbiano un senso per il ricevente.
Per sperimentare si può fare una prova, ma perché tutto abbia un senso dobbiamo creare un protocollo.
Ciao.
il serial monitor e una cosa che fa parte dell'ide e se si mette una cifra e si preme invio sulla tastiera del pc si comporterà sempre alla stessa maniera indipendentemente se lo sketc di arduino lo decodifica correttamente o meno
]