gps data logger

Grazie. Sono spiegazioni preziose.
Devo rileggerlo bene, perché mi ci sono perso
Io con la programmazione sono negato. Ci provo, a volte, ma con risultati deludenti.

Dai, conto su di te!

 

avoglia.. si risolve tutto .. .. forse.
ad ogni modo lo sketch è funzionante e quelli che seguiranno saranno anche migliori.
potrebbe esserci da installare qualche libreria ma è facile.


piuttosto sto notando che il modulo gps sarebbe meglio se avesse la sua porta usb.

sto modificando un sacco di parametri attraverso u-blox center e il gps collegato alla sua com usb..
è pure difficile ma è proprio qui che si setta il gps per ottenere dati attendibili, mi sto studiando questo simpatico pdf https://www.u-blox.com/sites/defaul...DescriptionProtocolSpec_(GPS.G6-SW-10018).pdf
non ho idea se gli altri gps senza usb si possono programmare altrettanto bene come sto facendo col mio, credo che comunque servirebbe una nano come ponte di connessione dai piedini 0-1 tx-rx della porta uart1 altrimenti mica li cambi i paramentri di config u-blox del gps..



quindi non so dire se un comune neo6m senza porta usb si configuri altrettanto bene, magari funziona alla prima... se così non fosse potrebbe far diventare macchinoso fare il setup obbligando a spostare i piedini per usare la usb della nano e poi rimetterli su altri di origine per poter caricare gli sketch...

se invece il gps ha già la sua usb basta collegarsi a quella per settarlo, mentre alla usb della nano ti colleghi solo per lavorare sul programma arduino.

u-blox center è questo https://www.u-blox.com/en/product/u-center

 

In pratica poi ti segna il percorso!

 

non è uno smartphone che ti disegna un percorso sulla carta, anche se non ho approfondito nulla su questo.. il file log è un banale txt ma penso si possa scrivere anche in altri formati, non so nulla in proposito.
la scatolina fornisce un log di coordinate, ti segna i metri e chilometri percorsi con ragionevole approssimazione specialmente se ti fermi spesso e il gps deve liberarsi il buffer scaricando il dato a zero..
invece se vai relativamente costante misura abbastanza preciso.
poi ti dice la velocità di camminata e quella massima raggiunta.
infine ti indica l'altitudine e i dislivelli percorsi, però i dati dell'altitudine sono soggetti a un valido fix 3d del gps.. e su questa questione ci sto ancora spippolando tramite Ublx-center e u-blox configuration perchè lo sketch sembra non avere nessun problema, ho rilevato anche varie altezze ma è un dato che vedo cambiare davvero di rado, stasera per esempio è rimasto a zero per tutta la girata, oggi pomeriggio in giardino con lo stesso sketch l'altitudine l'ha scritta 3 volte con valori simili.

se volete dargli un'occhiata, lo sketch funziona tutto e rileva anche l'altitudine almeno quando il gps si decide a fare un fix 3d decente.

u-blox è complesso, se scopro l'arcano e i settaggi ideali li scriverò in questo 3d.

intanto in questa ultima versione ho sistemato la legenda sulla SD log.txt.
ho eliminato alcune stringhe secondarie che rubavano spazio solo per avvertire che non arriva segnale.
ho lasciato il rilevatore di velocità col buzzer( /led / relè o quello che volete attivare ) da impostare a piacimento: se collegato tra gnd e il piedino 6 arrivati a una determinata velocità (es. 50kmh) manda corrente sul piedino.

questo è il nuovo codice.

Codice:

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <SoftwareSerial.h>
//#include <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire lcd;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;
float alt;
NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4;
static const uint32_t GPSBaud = 9600;
SoftwareSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
    int show          = INITIAL_SHOW;
const int   BUZZER_PIN  = 6;
const float SPEED_LIMIT = 0.1; //55.0; // kph
int maxs = 0;
void setup(){
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
lcd.begin(&Adafruit128x64, I2C_ADDRESS);
lcd.setFont(TimesNewRoman16_bold);
lcd.clear();
lcd.println("  GPS LOGGER");
lcd.println(" ");
lcd.println("   WELCOME");
delay(3000);
lcd.clear();
if(!SD.begin(cs_sd)){
lcd.clear();
lcd.println(" ");
lcd.print("NO SD");
delay(3000);
return;}
lcd.println(" ");
lcd.print("SD Card OK");
delay(2000);
lcd.clear();
File data = SD.open("log.txt",FILE_WRITE);           
data.println("");
data.println("Data   Ora+2     Lat     Lon      Alt   Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort )) {
gps_fix fix = gps.read();
show = (show + 1) % SHOW_INTERVAL;
if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( BUZZER_PIN, HIGH ); 
 } else {
 digitalWrite( BUZZER_PIN, LOW ); }
 if (fix.valid.location) {
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if ( Speed > maxs)
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude () );
if (show == 0) {
#define MAX_CHARS 22
char displayBufffer[MAX_CHARS];
lcd.setCursor(0,0); 
snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odo, (int)(odo * 100)%100);
lcd.println(displayBufffer); 
snprintf(displayBufffer, MAX_CHARS, "Kmh:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Vmx:  %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);
lcd.println(displayBufffer);} 
String Temps=String(fix.dateTime.hours +1)+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String Date=String(fix.dateTime.day)+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);
File data=SD.open("log.txt",FILE_WRITE);
data.println(Date +("  ")+ Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+String(alt)+("  ") +String(Speed)+("  ")+ String(odo));
data.close();}}

tutti i dati vengono descritti nel log.txt, con ora e data, ogni volta che si spegne o si interrompe col reset riparte un nuovo conteggio.
per quanto riguarda il dato orario non ho spazio sufficiente sulla nano per aggiungere il calcolo del timezone, ho solo scritto sulla legenda ore+2 che sono la differenza di ore in Italia rispetto alla lettura scritta.
il fix impiega anche parecchio tempo per attivarsi quindi molte stringhe di report iniziali saranno tutte scritte a zero.
sarebbe interessante precludere la possibilità di scrivere fin quando non arriva un dato float ma temo di non poter aggiungere altro salvo non snellire lo sketch in qualche modo.. oppure metterlo su una arduino uno molto più grande.

 

abbiate pazienza.. è tutto sperimentale e in sperimentazione.. oggi ho ottenuto grandi risultati con l'altitudine..
ho fatto alcune minime modifiche allo sketch e a questo punto credo davvero che sia tutto risolto.

Codice:

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <SoftwareSerial.h>
//#include <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire lcd;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;
int alt;
NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4;
static const uint32_t GPSBaud = 9600;
SoftwareSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
    int show          = INITIAL_SHOW;
const int   BUZZER_PIN  = 6;
const float SPEED_LIMIT = 0.1; //55.0; // qui scrivete la velocità alla quale deve attivarsi il piedino 6 buzzer pin
int maxs = 0;
void setup(){
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
lcd.begin(&Adafruit128x64, I2C_ADDRESS);
lcd.setFont(TimesNewRoman16_bold);
lcd.clear();
lcd.println("  GPS LOGGER");
lcd.println(" ");
lcd.println("   WELCOME");
delay(3000);
lcd.clear();
if(!SD.begin(cs_sd)){
lcd.clear();
lcd.println(" ");
lcd.print("NO SD");
delay(3000);
return;}
lcd.println(" ");
lcd.print("SD Card OK");
delay(2000);
lcd.clear();
File data = SD.open("log.txt",FILE_WRITE);         
data.println("");
data.println("Data   Ora+2     Lat      Lon      Alt   Vel  Dis" );
data.close();}
void loop(){
if (gps.available( gpsPort )) {
gps_fix fix = gps.read();
show = (show + 1) % SHOW_INTERVAL;
if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( BUZZER_PIN, HIGH );
 } else {
 digitalWrite( BUZZER_PIN, LOW ); }
 if (fix.valid.location) {
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if ( Speed > maxs)
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude () );
if (show == 0) {
#define MAX_CHARS 22
char displayBufffer[MAX_CHARS];
lcd.setCursor(0,0);
snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odo, (int)(odo * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Kmh:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Vmx:  %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);
lcd.println(displayBufffer);}
String Temps=String(fix.dateTime.hours +1)+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String Date=String(fix.dateTime.day)+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);
File data=SD.open("log.txt",FILE_WRITE);
data.println(Date +("  ")+ Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+String(alt)+("  ") +String(Speed)+("  ")+ String(odo));
data.close();}}
 

vi lascio anche alcuni settaggi di u-blox che mi hanno migliorato la situazione.
questi settaggi si modificano con il programma u-blox center e riguardano solo il componente gps.
io credo che se non avete la porta usb sul gps potete comunque editarli usando la usb della nano con i piedini tx rx messi nei corrispondenti rx0 tx1 presenti sulla nano board.. non ho provato ma penso che dovrebbe funzionare.

menu view configure: (elenco solo le voci modificate rispetto al default)
NAV5= (pedestrian 3d only minSV elevation =2)
RATE= ( utc time measurement period 500)
NAV MESSAGES= ( (flaggare uart1 e scrivere 1 per le seguenti voci) nav-sol navtime-utc nav-velned nav-dop nav-posllh navtime-gps)
NAV MESSAGES= ((flaggare uart1 e scrivere 5 per le seguenti voci) nav-status nav-svinfo)
ricordatevi di premere send ogni volta che cambiate qualcosa e alla fine andare in CFG e scrivere tutto sulla eprom.


con questi settaggi sto avendo dati vivaci nell'essere scritti sul display e nel complesso abbastanza attendibili
il fix 3d only è un filino più lungo, oggi che è nuvoloso ha richiesto 4 minuti.

infine ho corretto il disegno aggiungendo il cicalino del limite di velocità che potete impostare nella stringa con l'unica nota di testo presente nel nuovo sketch.




quanto alla carta, volevo dire mappa.. ho provato semplicemente a prendere le stringhe latitudine e longitudine scritte sul log.txt e le ho inserite su google maps e funziona subito alla prima talmente bene che mi ha localizzato il segnalino in giardino.

 

in questa versione ho cambiato tipo di file che viene salvato sulla SD.
lo sketch è identico eccetto per il file log.csv leggibile con excel oppure open office.
inoltre è diverso per il numero di spazi tra le varie voci che compongono la legenda.. sul txt ho dovuto aggiungere spazi per allinearmi, con questo csv ne bastano 2 tra ogni dicitura.
questo è il codice, lo potete facilmente confrontare con l'altro e capire le differenze:

Codice:

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <SoftwareSerial.h>
//#include <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire lcd;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;
int alt;
NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4;
static const uint32_t GPSBaud = 9600;
SoftwareSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
    int show          = INITIAL_SHOW;
const int   BUZZER_PIN  = 6;
const float SPEED_LIMIT = 0.1; //55.0; // kph
int maxs = 0;
void setup(){
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
lcd.begin(&Adafruit128x64, I2C_ADDRESS);
lcd.setFont(TimesNewRoman16_bold);
lcd.clear();
lcd.println("  GPS LOGGER");
lcd.println(" ");
lcd.println("   WELCOME");
delay(3000);
lcd.clear();
if(!SD.begin(cs_sd)){
lcd.clear();
lcd.println(" ");
lcd.print("NO SD");
delay(3000);
return;}
lcd.println(" ");
lcd.print("SD Card OK");
delay(2000);
lcd.clear();
File data = SD.open("log.csv",FILE_WRITE);
           
data.println("");
data.println("Data  Ora+2  Lat  Lon  Alt  Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort )) {
gps_fix fix = gps.read();
show = (show + 1) % SHOW_INTERVAL;
if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( BUZZER_PIN, HIGH ); 
 } else {
 digitalWrite( BUZZER_PIN, LOW ); }
 if (fix.valid.location) {
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if ( Speed > maxs)
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude () );
if (show == 0) {
#define MAX_CHARS 22
char displayBufffer[MAX_CHARS];
lcd.setCursor(0,0); 
snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odo, (int)(odo * 100)%100);
lcd.println(displayBufffer); 
snprintf(displayBufffer, MAX_CHARS, "Kmh:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Vmx:  %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);
lcd.println(displayBufffer);} 
String Temps=String(fix.dateTime.hours +1)+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String Date=String(fix.dateTime.day)+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);
File data=SD.open("log.csv",FILE_WRITE);

data.println(Date +("  ")+ Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+String(alt)+("  ") +String(Speed)+("  ")+ String(odo));
data.close();}}

in questo modo la lettura del file "log.csv" in open office vi apparirà così:



i dati sono tutti sballati.. sono in casa e il gps non prende, è normale leggere date e orari assurdi e tutti zeri nelle coordinate quando il fix non è stato effettuato
.
ora+2 indica lo scarto che c'è tra l'ora italiana e quella del gps.. non c'è spazio sulla nano per fare una conversione dell'orario nel programma.

vedete anche che tra un reset e l'altro si riforma la legenda per fare meglio le letture parziali

usando invece il file log.txt presente nel codice del post precedente otterrete questo tipo di visualizzazione:

 

adesso questo gps lo testo a fondo, poi magari metto un 3d nel tutorial di elettronica con spiegato in dettaglio tutto il procedimento per la costruzione in modo che nessuno si perda nelle prove che ho fatto e chiunque possa costruirlo.
prima voglio provare se funziona il buzzer che indica il limite di velocità, io metterò un led giusto per fare la verifica e magari poi lo imposto su 9kmh giusto per vedere quanto è inutile misurare se in discesa supero la velocità massima del camion dynahead rispetto a quando viaggia a tutto gas in pianura.

a breve mi vorrei dedicare a un nuovo progetto.. un tilt monitor che misura l'inclinazione laterale e la distanza da ostacoli vicini come un comune sensore di parcheggio.
pensavo di usare un gyro mpu6050 e un sensore a ultrasuoni hcsr 04 e l'immancabile nano.
se riesco a farlo vorrei che il tilt monitor vivesse in cabina tipo orizzonte artificiale in modo da vederlo in fpv, idem il dato della distanza in centimentri dagli ostacoli.
il display non ho ancora idea.. chredo che i piccoli oled senza buffer come quello usato sul gps non siano adatti ma vedremo.
se non riesco ad aggiungere un display decente in cabina mi accontenterò di un sensore di parcheggio posteriore preimpostato a una ventina di cm in modo da far manovra senza sbattere.

 

ho provato adesso l'allarme di velocità e ho fatto alcune modifiche.

ho spostato tutto sul piedino 3
avendo messo un led ho riscritto lo sketch e ho impostato un limitatore a 6kmh che sarebbe poco meno della velocità massima del dynahead.
giusto perchè c'è questa finzione metterò un led sulla scatola per visualizzarla.. il cicalino mi rifiuto
ah.. ho anche cambiato il piedino 6 col piedino 3 per praticità dato che il 6 l'avevo tagliato.. non dovrebbe esserci differenza di funzionamento.

ho scritto il codice in questo modo:

Codice:

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <SoftwareSerial.h>
//#include <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire lcd;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;
int alt;
NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4;
static const uint32_t GPSBaud = 9600;
SoftwareSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
    int show          = INITIAL_SHOW;
const int   LED_PIN  = 3;
const float SPEED_LIMIT = 6.0; // es: 55.0; // kmh
int maxs = 0;
void setup(){
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
lcd.begin(&Adafruit128x64, I2C_ADDRESS);
lcd.setFont(TimesNewRoman16_bold);
lcd.clear();
lcd.println("  GPS LOGGER");
lcd.println(" ");
lcd.println("   WELCOME");
delay(3000);
lcd.clear();
if(!SD.begin(cs_sd)){
lcd.clear();
lcd.println(" ");
lcd.print("NO SD");
delay(3000);
return;}
lcd.println(" ");
lcd.print("SD Card OK");
delay(2000);
lcd.clear();
File data = SD.open("log.csv",FILE_WRITE);
            
data.println("");
data.println("Data  Ora+2  Lat  Lon  Alt  Vel  Dis" );  
data.close();}
void loop(){
if (gps.available( gpsPort )) {
gps_fix fix = gps.read();
show = (show + 1) % SHOW_INTERVAL;
if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN, HIGH );  
 } else {
 digitalWrite( LED_PIN, LOW ); }
 if (fix.valid.location) {
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if ( Speed > maxs)
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude () );
if (show == 0) {
#define MAX_CHARS 22
char displayBufffer[MAX_CHARS];
lcd.setCursor(0,0);  
snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odo, (int)(odo * 100)%100);
lcd.println(displayBufffer);  
snprintf(displayBufffer, MAX_CHARS, "Kmh:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Vmx:  %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);
lcd.println(displayBufffer);}  
String Temps=String(fix.dateTime.hours +1)+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String Date=String(fix.dateTime.day)+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);
File data=SD.open("log.csv",FILE_WRITE);

data.println(Date +("  ")+ Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+String(alt)+("  ") +String(Speed)+("  ")+ String(odo));
data.close();}}

 

ho aggiunto un led al posto del buzzer e per farlo funzionare ho dovuto scrivere una nuova stringa di codice.
adesso è impostato per accendersi da una velocità di 0,0 kmh giusto per provare al volo il funzionamento.
come avviene il fix adesso si accende e forse lo lascio proprio così per indicare quando è agganciato il segnale gps
andrebbe aggiunta una resistenza da 180-220 Ohm su uno dei 2 poli del led


questo è il codice modificato per far accendere il led

Codice:

  #include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <SoftwareSerial.h>
//#include <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire lcd;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;
int alt;
NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4; //-- gps pin
static const uint32_t GPSBaud = 9600;
SoftwareSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
    int show          = INITIAL_SHOW;
const int   LED_PIN  = 3;  //-- led on at speed limit
const float SPEED_LIMIT = 0.0; // --setup speed limit value es: 55.0; kmh
int maxs = 0;
void setup(){
  pinMode (LED_PIN, OUTPUT);
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
lcd.begin(&Adafruit128x64, I2C_ADDRESS);
lcd.setFont(TimesNewRoman16_bold);
lcd.clear();
lcd.println("  GPS LOGGER");
lcd.println(" ");
lcd.println("   WELCOME");
delay(3000);
lcd.clear();
if(!SD.begin(cs_sd)){
lcd.clear();
lcd.println(" ");
lcd.print("NO SD");
delay(3000);
return;}
lcd.println(" ");
lcd.print("SD Card OK");
delay(2000);
lcd.clear();
File data = SD.open("log.csv",FILE_WRITE);        
data.println("");
data.println("Date  Ora+2  Lat  Lon  Alt  Vel  Dis" ); //-- Hr+ add your local time difference
data.close();}
void loop(){
if (gps.available( gpsPort )) {
gps_fix fix = gps.read();
show = (show + 1) % SHOW_INTERVAL;
if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN, HIGH );
 } else {
 digitalWrite( LED_PIN, LOW ); }
 if (fix.valid.location) {
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if ( Speed > maxs)
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude () );
if (show == 0) {
#define MAX_CHARS 22
char displayBufffer[MAX_CHARS];
lcd.setCursor(0,0);
snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odo, (int)(odo * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Kmh:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, "Vmx:  %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);
lcd.println(displayBufffer);
snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);
lcd.println(displayBufffer);}
String Temps=String(fix.dateTime.hours +1)+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String Date=String(fix.dateTime.day)+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);
File data=SD.open("log.csv",FILE_WRITE); //--   excel or open office file
data.println(Date +("  ")+ Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+String(alt)+("  ") +String(Speed)+("  ")+ String(odo));
data.close();}}

 

stasera ho testato meglio il gps con letture dell'altitudine e conseguenti variazioni nei punti più alti raggiunti durante la passeggiata.
per fare una riprova la prossima girata mi porterò dietro il vecchio garmin nuvi per vedere di quanto possa essere lo scarto tra i 2 gps.
per il momento il dato sembra abbastanza attendibile anche secondo i miei piedi..
il led è restato acceso tutto il tempo eccetto 2 volte di cui una per 5 secondi dove ero anche fermo, quindi può aver rilevato gli zero kmh e si è spento.
è comunque comodo per controllare che stia arrivando il segnale gps, impostarlo come allarme di velocità ha poco senso.

adesso sono curioso di leggere la SD e il lunghissimo log file che avrà fatto, soprattutto per vedere come ha rilevato le salite e le discese.
sul camioncino ha raggiunto una velocità massima di 9kmh e ha percorso 8.4km.
la velocità istantanea si scarica lentamente in una decina di secondi e non segna quasi mai zero spaccato..
l'altitudine sembra qualcosa in più rispetto alla partenza.. a occhio 5 metri tutti, controllerò meglio sulla SD.
latitudine e longitudine invece sono molto precise.
verificato su google map, se mi sposto dentro il mio giardino di 8x8mt vedo una piccola differenza.



ah.. ho messo il gps su project hub

https://create.arduino.cc/projecthu...gxK8j4LKFQT2DXl_zJh6JWiUQfGMv06ZVZi_1I9kdcnbM

 

per favore potete aiutarmi a capire come potrei fare una modifica?
soprattutto vorrei capire cosa sarebbe utile ottenere.

attualmente il gps riporta sul display e su SD l'altitudine slm che viene misurata. lo fa abbastanza male e di rado ma questo è un altro problema..

questo dato slm in parte va benissimo, mi interessa sapere i metri sul livello del mare e vorrei conservare questa lettura magari solo sul log nella scheda SD.

sul display invece al posto dell'altitudine slm mi piacerebbe visualizzare il totale del dislivello percorso.
e questo forse lo so pure scrivere generando una "int dislivello =0 " sarebbe del tutto simile al calcolo per la massima altitudine della loggertation iniziale, non so come si comporterebbe sulle discese e i numeri sotto lo zero ma potrei arrivarci.

però considerando i nostri mezzi questo dislivello penso che dovrebbe essere differenzialto sia in discesa che in salita perchè è un dato che mi serve a capire l'usura meccanica e il consumo delle batterie quando il camion risale crinali e fa vitaccia stressante nei trekking per i boschi.
quindi mi chiedo quale sia il modo migliore e più utile di collezionare il dislivello percorso.

per esempio se scendo 110mt e risalgo 100mt annullerei il dislivello (sul display ok) mentre il dato che penso sarebbe interessante leggere su SD sarebbe +100 / -110.
visto che il dato si aggiorna continuamente potrebbe essere utile scriverlo su 2 colonne separate così da capire se siano salite o discese ma va bene anche veder crescere un dato + oppure un dato negativo e segnarsi i picchi dal PC di casa.
sarebbe comunque un numero intero progressivo, il camion sale +1,+3,+9 metri e scende -2 -5 -10 metri etc quindi potrebbe essere letto su una colonna col segno matematico oppure meglio su 2 colonne nelle quali viene scritta solo quella relativa alla salita/discesa.

sul display invece potrebbe apparire scritto solo il totale del dislivello della girata, ovvero zero se torno al punto di partenza ma azzerando il reset posso anche avere sul display dei parziali mentre su sd pur azzerandosi continuerà a scrivere listati di salite o discese.
resettando andranno poi sommati i parziali della distanza percorsa salvo non aggiungere un pulsante per resettare il dato del dislivello solo al display.


qualcuno ha voglia di aiutarmi a capire da dove partire per scrivere questa funzione?

ho anche qualche dubbio sul carico di lavoro e spazio disponibile sulla nano.
sto anche valutando di costruirne uno nuovo con micro sd display bianco e gps n8m con porta usb e vedere se tutto funziona anche meglio di adesso, se non dovesse bastare la nano potrei comunque usare un'altra scheda.

 

Ma se il dato di dislivello percorso ti serve poi per valutare l’uscita non potresti semplicemente aumentare il campionamento dei dati sulla SD e poi generare un grafico del percorso a posteriori con programmi tipo Excel?

 

non saprei come aumentare il campionamento dei dati su SD.


il dato dell'altitudine slm sul display serve a poco, potrebbe benissimo apparire solo il dislivello percorso.
con excel i dislivelli già li potrei calcolare sottraendo l'altitudine slm dal punto di partenza, ma per semplificare la lettura del log e dei dati raccolti sulla SD potrebbero essere scritti a parte anche i soli dislivelli di salita e discesa.

sempre che aggiungere il calcolo di queste variabili e farle scrivere non rallenti tutto quanto.

dopo provo così..
int dislivello discesa =0;
int dislivello salita =0;
int dislivello;

alt = ( fix.altitude () );
if ( dislivello salita > alt) {
alt = dislivello;
}
if ( dislivello discesa < alt) {
alt = dislivello;
}
snprintf(displayBufffer, MAX_CHARS, " Alt : % 3d.%02d", (int)dislivello, (int)(dislivello * 100)%100);
lcd.println(displayBufffer);}

 

il problema principale e irrisolvibile nel poter calcolare il dislivello escludendo l'altitudine slm è che non ho spazio di memoria sulla nano nemmeno per aggiungere una sola stinga di codice.

quindi non modifico niente e lo continuo ad usarlo alla sua ultima versione che funziona molto bene.
su Arduino project hub ho aggiunto una versione del codice adatta ai display da 1,3'' che si leggono meglio di quelli da 0,96''
infatti in questi giorni costruirò un secondo gps molto più piccolo e compatto del precedente, conto di ridurlo abbastanza da farlo entrare in uno scatolino di 39x78x20mm
nella scatola dovranno entrare le 4 schede che lo compongono (nano, micro sd logger, modulo gps, display 1,3'') più un led, un pulsante e una presa di alimentazione generica.

metterò qualche foto appena possibile.

 

ecco qui il nuovo gps.
è essenzialmente identico all'altro ma concentrato in metà spazio con un display bianco molto più grande e leggibile.
4 schede in tutto: la board nano v3, una micro sd reader, un gps neo n6m con porta usb (fondamentale per programmarlo in ublox center e abilitare i nav messages) e un display da 1,3 pollici bianco + un led con resistenza da 330ohm per leggere il fix (oppure impostarlo come speed limit a 50kmh ) e un pulsantino normalmente aperto per il reset.
ha una presa bec per alimentarlo con qualsiasi batteria esterna anche se si alimenta comunque da entrambe le porte usb.
infine uno scatolino di plastica fresato e modellato.











confrontato con la prima versione è più sottile e decisamente più piccolo.
questo nuovo gps lo monterò fisso sotto la carrozeria del dynahead e si accenderà insieme al camion.
il vecchio gps adesso mi servirà per riscontrare che il nuovo funzioni bene, poi lo modificherò: vorrei aggiungere una seconda nano, un secondo display, e una bussola.

 

Mamma mia che spettacolo.
Da grande voglio diventare come Wrighizilla.
Di più non saprei cosa dire.

 

Quoto, e rinnovo i miei complimenti perchè Wrighi sa fare statico, dinamico e pure elettronica e programmazione come si vede in questo (e altri) 3d