PROBLEMA CON MESSAGGIO DI ATTESA SU DISPLAY

Salve a tutti. Sono nuovo del forum e sopratutto nuovo esploratore di questo affascinante dispositivo. Inizio col ringraziare tutti premettendo che sono molto piu' "elettronico" che "informatico" e probabilmente il problema che descriverò farà sorridere che sa programmare anche solo decentemente. Descrivo il progetto o meglio questo primo step. Arduino uno collegato a display seriale TTL (ci scrivo serialmente semplicemente inviando i testi) tramite seriale emulata software.library (pin 7 ed 8 ). Ho scelto di collegare il display alla seriale emulata via software perchè la seriale nativa mi servirà per collegarci successivamente un dispositivo che dovrà avere priorità nell' affidabilità della comunicazione. Il funzionamento, almeno per questo primo test dovrà essere il seguente: in standby il display dovrà visualizzare un messaggio di attesa, sempre lo stesso fino a quando sulla seriale arriva una stringa. Appena arrivata la stringa sulla seriale nativa, arduino la deve riportare pari pari sul display, attendere qualche secondo, cancellare il display e inviare nuovamente il testo di attesa che persisterà fino a nuovo messaggio su seriale. Sono riuscito a scrivere il software che predispone il messaggio sul display in attesa, ma nel momento in cui invio la stringa sulla seriale il ciclo di scrittura e cancellazione mi va in loop e visualizzo ciclicamente ogni singolo carattere inviato seguito dalla cancellazione del display ed il ritorno del messaggio di attesa fino al completamento della stringa inviata. Vi riporto il codice:

#include <SoftwareSerial.h>
 
//creo una nuova porta seriale via software
SoftwareSerial PortaSeriale =  SoftwareSerial(7, 8);
 
//variabili
char Lettodaseriale = 0;
char scritturadisplay = 0;

void setup()  {
//definisco il pin7(RX) come ingresso
pinMode(7, INPUT);
//definisco il pin8(TX) come uscita
pinMode(8, OUTPUT);
//setto la velocita della seriale hardware
Serial.begin(9600);
//setto la velocita della seriale software
PortaSeriale.begin(9600);
delay(100);
//pulisco display
PortaSeriale.write(0xFE);
PortaSeriale.write(0x58);
delay(100);
//scrivo attesa
PortaSeriale.print("        Lynx           by iDsolutions                          Attesa Lettura   ");
}

void loop()  {
if (Serial.available() > 0) {
 Lettodaseriale = Serial.read();
 scrittura_display ();
 delay(10);
}   
}

void scrittura_display()  {
   PortaSeriale.print (Lettodaseriale);  
   delay (4000);
   pulizia_display();
}

void pulizia_display()  {
   //pulisco display
PortaSeriale.write(0xFE);
PortaSeriale.write(0x58);
delay(100);
   //scrivo attesa
PortaSeriale.print("        Lynx           by iDsolutions                          Attesa Lettura   ");
}

Sicuramente avrò fatto errori madornali e me ne scuso..ma dovrò pur iniziare anch'io. XD XD

Grazie a tutti!!

ciao ton_ino
I pin 7 e 8 non serve definirli con pinMode

Il codice che hai scritto prende 1 carattere dalla seiale, lo stampa sul display aspetta 4 secondi cancella il display, mette la scritta di standby e poi prende il sucessivo carattere.

devi fare un loop che Ti legge tutti i cartteri spediti, stamparli e poi fare la pausa.
Ciao Uwe

Cio Uwe,

felicissimo di ricevere la tua risposta, avevo già letto qualche tuo intervento (prima di fiondarmi sul forum ho cercato di documentarmi un pò). In realtà alimentando la scheda avviene proprio ciò che hai descritto. Potresti spiegarmi meglio in cosa sbaglio casomai postandomi un esempio??

Grazie infinite.

Uwe ti ha già spiegato in cosa sbagli :wink:
Leggi 1 solo carattere dalla seriale.

Per capire meglio partiamo da qui:

Poi leggi i metodi dell'oggetto Serial, nello specifico "read":

Come vedi, in questa maniera non leggi tutto quello che arriva ma solo 1 carattere.
Ti serve intanto un oggetto stringa in cui riversare quello che arriva, e poi alla fine della ricezione puoi mandare a video la stringa.
Devi quindi immagazzinare tutto quello che arriva o in un oggetto String:
http://arduino.cc/en/Reference/String
oppure in un array di char:
http://arduino.cc/en/Reference/String

Vedi tu qual è più compatibile con la libreria che stai usando e che ti viene meglio da gestire.

Infine, ti consiglio una ricerca sul forum perché la ricezione dei messaggi via seriale è un argomento che viene fuori frequentemente e di esempi di codice ne trovi veramente molti.

Il codice lo puoi anche lasciare così, l'unica cosa che devi fare e cancellare il display dopo x tempo che il messagio inviato su seriale hardware è da considerare terminato.

Appunto quando il messagio è considerato terminato?
Per dire al codice quando il messagio è terminato puoi usare un carattere/codice fine trasmissione messagio, questo deve essere posto alla fine così: "Eureka\n".

Il barra n è una sequenza di escape, io non so se il serial monitor di arduino lo invia correttamente, in alternativa puoi usare qualunque carattere.

Nel codice devi testare ogni carattere letto da read per trovare quello di fine messaggio.
Es.

if (Serial.available() > 0) {
 Lettodaseriale = Serial.read();
 if (lettodaseriale == '\n')
     delay(xxx); 
     clear display
else
    scrittura_display ();

La funzione scrittura _display non deve cancellare il display.

Piccola nota:
se vuoi al fine di mantenere il codice in ordine e quindi leggibile poi usare le macro del preprocessore C
che sostituiscono il codice che scrivi dopo il nome della macro prima di avviare il compilatore.

Es.

// dopo le #include
#define CLR_LCD PortaSeriale.write(0xFE); \
                              PortaSeriale.write(0x58)

// uso 
CLR_LCD;

Ciao.

Ciao Mauro,

seguendo i tuoi consigli sono riuscito a gestire l'invio dei caratteri fino a quello di terminazione. Il problema è che con questo metodo il carattere di terminazione deve essere per forza unico perchè a quanto ho capito viene processato un byte alla volta e inoltre non posso manipolare la stringa in arrivo ad esempio per controllarne la lunghezza, l'inizio o la fine per rendere più sicuro il protocollo o cmq per eseguire altre operazioni tipo chiusura di un relè che mi servirà successivamente (avevo in mente un comando del tipo *RON da riconoscere come stringa). Mi sono documentato, come mi consigliava Leo, sul metodo serial.readBytes e sarebbe interessante poterlo utilizzare in modo da avere una stringa da manipolare con il comando String. Ho cercato qualche esempio in rete ma non torvo applicazioni vere e proprie. Sarei felice di poter apprendere da qualche esempio.

Grazie infinite a tutti.

Prova qui Arduino Playground - InterfacingWithSoftware
se trovi info riguardo al protocollo.

Genericamente c'è firmata, che deriva dal protocollo MIDI se non ricordo male. Se non trovi qualcosa di pronto da usare
sei costretto a scrivere un protocollo personalizzato e allora ti tocca sudare e studiare.

L'argomento è troppo ampio per me e non sono in grado di darti delle info risolutive, posso solo teorizzare.

Il protocollo software lavora su quello hardware, se il protocollo seriale rs232 è conosciuto molto meno o per niente lo sono i protocolli software, tocca quindi documentarsi sui protocolli software uno appunto è firmata, ma c'è ne sono altri che nascono dalla fantasia degli sviluppatori, alcuni sono a frame fisso, altri stabliscono il frame volta per volta sfruttando un frame fisso, davvero qui c'è da perdersi facilmente.

Concordo con il fatto che il metodo usato non è buono per costruirci su un protocollo, quel tipo di trasfermento si usa all'interno di un protocollo quando vuoi trasferire un numero elevato di informazione non gestendo affatto ogni singolo dato.

Vedi un pò tu cosa trovi e facci sapere com'è andata.

Ciao.