Grazie molte per la tua disponibilità poichè sei l'unico che mi ha fatto comprendere qualcosa scusa ancora per il disturbo e grazie per il tuo tempo
Non pensarlo nemmeno
Lo ho fatto volentieri, per un mio piacere personale nel "trovare" cose e migliorare programmi
Perdona ... ma quale indizio in più?
Più che dirti:
e
che ti devo dire ? ![]()
Guglielmo
Fai una prova, scrivi un programmino che legge SOLO il GPS usando i pin e le librerie che usi adesso e vedi se va ... se, ti funziona metti qui il sorgente.
Guglielmo
Scusatemi,
Entrambi
Per lo OP non volevo essere scortese
Per C1P8 non volevo appropriarmi di nulla
Quindi scusatemi
Passiamo a noi
Vedo un poco di confusione
Sms va, da solo
Gps va, da solo
Uniti va o uno o l'altro
Vediamo il programma e troviamo il problema
Per quanto riguarda i 66mS che cita Guglielmo
Ha certamente ragione, ma siccome la cadenza delle sentenze NMEA è di un secondo non muore nessuno se controllo prima il gps e solo dopo una sentenza valida ignoro il gps e passo al gsm
In un secondo non è che arrivino tanti sms
Nel tempo di lettura di un sms non è che cambi molto la posizione (se non sei a bordo di un F35)
Vero, ma ... a quel punto ti spara una raffica di sentenze (e non una) e le librerie classiche si incasinano. Io e te ne abbiamo già discusso ... bisognerebbe modificare il settaggio del GPS e farsi mandare solo quel paio di sentenze che veramente servono e non la sbrodolata di centiania di caratteri che ogni secondo vengono sparati.
Guarda, ho avuto lo stesso identico problema con la libreria GPS di Arduino usata assieme alla libreria LoRa ed i rispettivi hardware ... bastava un nulla per non avere più alcun risultato dal GPS (che in realtà trasmetteva regolarmente, era la libreria che non capiva più nulla).
Guglielmo
Tu sai che è proprio questo che voglio fare, adesso sono al mare e non mi serve di sapere dove sono
Ma quando (se, me è storia differente) torno a casa ci voglio guardare dentro
Per intanto posso dare uno sguardo a questo programma...
Questa no
http://arduiniana.org/libraries/tinygps/
appena provata
ho dovuto solo caricare l'esempio, cambiare la velocità delle seriali (il mio scrauso modulo gps cinese va a 9600)
aggiungere due righe di debug (che non sono servite) e provare ad usarla
andata al primo colpo, richiede solo + - e TX dal modulo a RX della UNO, la trasmissione dal modulo non è bidirezionale
ho staccato brutalmente il filo di RX e ha smesso di ricevere
riattaccato il filo ha ricominciato a ricevere in meno di un quarto di secondo
diverso è il caso se si "spegne" il modulo, che perde il sincronismo coi satelliti, ma se si disattiva la ricezione non da nessun problema, come giustamente sostenevo da un pezzo
basta peraltro guardare gli esempi stessi della libreria, che addirittura fa la decodifica OFF-LiNE di stringhe pre-memorizzate
per oggi basta, domani faccio qualcosa di più "evoluto"
a proposito, il mio programma, che peraltro è poco più del demo della libreria:
/* di Nelson-StandardOil
IDE 1.8.19
Progetto:
Scopo: provare varie configurazioni gps
Data inizio lavori:
*/
#include <TinyGPSPlus.h>
#include <SoftwareSerial.h>
static const int RXPin = 4, TXPin = 3;
static const uint32_t GPSBaud = 9600;
// The TinyGPSPlus object
TinyGPSPlus gps;
// The serial connection to the GPS device
SoftwareSerial ss(RXPin, TXPin);
void setup()
{
Serial.begin(9600);
ss.begin(GPSBaud);
Serial.println(F("DeviceExample.ino"));
Serial.println(F("A simple demonstration of TinyGPSPlus with an attached GPS module"));
Serial.print(F("Testing TinyGPSPlus library v. "));
Serial.println(TinyGPSPlus::libraryVersion());
Serial.println(F("by Mikal Hart"));
Serial.println();
}
void loop()
{
if (ss.available())
{
char c = ss.read();
// Serial.print(c);
if (gps.encode(c))
{
Serial.println("ricevuto qualcosa");
if (!gps.location.isValid())
{
Serial.println("dati non validi");
}
else
{
displayInfo();
}
}
}
}
void displayInfo()
{
Serial.print(F("Location: "));
if (gps.location.isValid())
{
Serial.print(gps.location.lat(), 6);
Serial.print(F(","));
Serial.print(gps.location.lng(), 6);
}
else
{
Serial.print(F("INVALID"));
}
Serial.print(F(" Date/Time: "));
if (gps.date.isValid())
{
Serial.print(gps.date.month());
Serial.print(F("/"));
Serial.print(gps.date.day());
Serial.print(F("/"));
Serial.print(gps.date.year());
}
else
{
Serial.print(F("INVALID"));
}
Serial.print(F(" "));
if (gps.time.isValid())
{
if (gps.time.hour() < 10)
{
Serial.print(F("0"));
}
Serial.print(gps.time.hour());
Serial.print(F(":"));
if (gps.time.minute() < 10)
{
Serial.print(F("0"));
}
Serial.print(gps.time.minute());
Serial.print(F(":"));
if (gps.time.second() < 10)
{
Serial.print(F("0"));
}
Serial.print(gps.time.second());
Serial.print(F("."));
if (gps.time.centisecond() < 10)
{
Serial.print(F("0"));
}
Serial.print(gps.time.centisecond());
}
else
{
Serial.print(F("INVALID"));
}
Serial.println();
}
@Standardoil: Staccando e riattacando è ovvio che va ... hai provato invece ad aggiungere un delay() (per simulare un ritardo) nel loop() ? Prova e fammi sapere (mi eviti la prova
)
Grazie. ![]()
Guglielmo
Non ho provato e non mi interessa provare
Il mio scopo era dimostrare che era possibile interrompere la ricezione per fare altre cose, senza perdere le comunicazioni successive, come vado dicendo da un pezzo, se ti ricordi
E, come ero sicuro, lo ho dimostrato
Ora lo OP sa cosa deve fare
A parte che sono convinto che anche con l'uso di un delay non cambia nulla, la parte "persa" della comunicazione è appunto persa (ovviamente)
Allo start successivo i giochi ricominciano, per convincersene basta guardare i sorgenti della libreria, che resettano i vari contatori
Se ti ricordi ho scritto da un pezzo varii esempi di "riconoscitori di comunicazione"
Che decodificano la seriale, ma il primo che ho scritto era addirittura per un Linbus
(Era per un carrello che non si era nemmeno preso la briga di leggere un data sheet, ma lo ho fatto volentieri perché mi serviva per il mio telegram bot e per il mio maggiordomo)
Ottenere il "sincronismo automatico" ad ogni successivo start della trasmissione è proprio il minimo sindacale, per una cosa del genere...
Hai solo dimostrato che interrompendo a caso la comunicazione e riprendendo pure a caso la libreria si riallinea subito ( o magari quasi subito)
Nulla è detto per il caso di buffer saturo, come dice Guglielmo
Oggi ce la avete con me?
Ho ottenuto il risultato che dicevo possibile (e altri no) e adesso prima mi si dice che è "ovvio" che sia così
Se fosse stato ovvio non mi avreste detto il contrario ancora pochi giorni fa
E poi mi si dice pure che non ho dimostrato quello che volevo dimostrare
NO
LO HO dimostrato!
Il caso del buffer cortisponde "esattamente" al caso del cavo interrotto
A elaborazione interrotta il baffer si riempie
A buffer pieno smette (in un punto casuale, nel senso di non pre-determinato) di registrare i caratteri in arrivo
Alla ripresa della gestione della rcezione la lettura riprende e in un punto parimenti casuale il buffer ricomincia a riempirsi
Abbiamo quindi una interruzzione casuale nella sequenza di caratteri ricevuti
Esattamente come se si staccasse il cavo
E con questo io chiudo
Ho dimostrato quello che dicevate essere impossbile e per me la cosa finisce qui
Ammetto
Ma rimane comunque inutile
Cosa gli diciamo a @luxed?
Di staccare il filo quando deve leggere gli SMS?
Non mi sembra pratico
Quindi come si dovrebbe comportare?
Come fa a fare la commutazione gps-gsm?
Come ho scritto giorni fa
Prima non bada al gsm
Quando ha una lettura gps valida ignora il gps e guarda il gsm
Una if() alla prima riga del loop
Che viene anche comodo fare due seriali software una per il gsm e una per il gps, che tanto ne va una sola per volta e il comando per attivarla è la funzione listen() che per comodità svuota il suo buffer, e così la sincronia della ricezione è ancora più facile
Ma io non capisco perché la seriale hardware vien configurata a 9600 e un limite di ciò che è connesso tipo il GSM.
Serial.print("Latitudine:");
Serial.print(gps.location.lat(), 6);
Serial.print(" ");
Serial.print("Longitudine:");
Serial.print(gps.location.lng(), 6);
Serial.println();
Tutti questi caratteri da inviare, vero che sono messi nel buffer
di trasmissione, ma poi da questo buffer il core li preleva e li spedisce impiegando circa 1.04 ms, Io penso che prima ci liberiamo il buffer di trasmissione meglio o ancora meglio 115200 ma scrivo i caratteri nel buffer lentamente. Ricordo che quando sta eseguendo codice all'interno della ISR nessun'altra ISR può essere servita.
Ciao.
Solo per dimostrare che non serve correre
Anche a bassa velocità il tutto funziona benissimo
Come si vede qui in questo argomento, come in molti altri, ci si è fatti un bel numero di seghe mentali, quando in realtà basta poco per ottenere risultati
In effetti, un minimo di analisi...
Dato che una sentenza è lunga fino a 84 caratteri
E che il modulo ne trasmette alcune varie...
E che la trasmissione sulla seriale HW è corta...
E che comunque la seriale HW è bufferizzata in HW, appunto...
Queste cose però non sono state fatte , prima
Prima si è sempre e solo detto che non era possibile farlo, quello che dicevo io...
Adesso torno a dormire
NO, non lo hai dimostrato e ti dico che il comportamento è del tutto differente ... poi tu credi ciò che vuoi, a me non cambia nulla, ma il comportamento è diverso. Anche per me la discussione finisce qui.
Guglielmo
Hai provato?
Ho provato io perché non ero convinto
Col programma di @Standardoil e mettendo un delay dopo una sentenza valida funziona esattamente come dice lui
Non ho ancora capito perché
La sua spiegazione non mi convince ma va
Edit mode on
Forse comincio a capire
Se non elaboro i caratteri in arrivo il buffer si riempie solo dei primi, poi li perde i successivi
Essendo che la libreria è asincrona con la ricezione non bada a quando sono stati ricevuti, e allora è come se ci sia stata una interruzione della linea
Raramente capito li da te, frequento più il pavese
Se capito ti avviso
Vabbè farò finta di aver accettato le vostre scuse per la evidente mancanza di fiducia in me
E accetterò volentieri un caffè a Varese quando ci passerete