gps data logger

Discussione in 'Come fare a...' iniziata da wrighizilla, 29 Maggio 2020.

  1. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    sto costruendo questo https://create.arduino.cc/projecthub/yvesmorele/rc-loggerstation-gps-data-logger-for-rc-plane-3ea4cd

    ho appena caricato lo sketch senza problemi, servivano giusto le librerie da includere.
    devo ancora collegare i pezzi che ho sul tavolo: un gps ublox neo 6, un display 128x64 una schedina sd lettura scrittura e una board nano

    avrei bisogno di una mano per capire come funziona lo sketch in modo da aggiungere o cambiare un parametro:
    vorrei aggiungere la distanza percorsa dall'accensione fino al momento della lettura o spegnimento.
    dato fondamentale che vorrei scrivere anche sulla sd per tenere una sorta di diario dei chilometri percorsi da un determinato modello.
    magari sostituirei la distanza percorsa al posto di un altro parametro meno importante se non dovesse entrare nello schermo, ad esempio la velocità istantanea che mi interessa relativamente oppure le coordinate.
    sapete aiutarmi a fare questa modifica? vorrei personalizzare il display inserendo alcune informazioni differenti.
    intanto vedo di collegare i pezzi e mettere una foto dell'array provvisorio.

    non so ancora bene di preciso cosa vorrei ottenere, quali sono i dati che potrebbero essere più interessanti da visulaizzare sul display e come leggere al meglio quelli scritti su sd.
    mi piacrebbe poter misurare i dislivelli, la distanza percorsa.
    magari sarebbe ottimo poter registrare su sd un file gpx o simile che posso poi visualizzare in google maps, oppure ancora meglio qui https://www.alltrails.com/explore?b...43.72184662672705&b_br_lng=11.154706478118896
     
    Last edited: 29 Maggio 2020
  2. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    dunque.. ho collegato l'oggetto e l'ho acceso.
    tanto per cominciare c'è un errore tra il codice e lo schema dell'array: cs_sd=2 implica di spostare il piedino proveniente dalla scheda sd sul piedino D2 invece di A6 come disegnato sullo schema. (filo grigio)
    ho perso un pò di tempo per capire quali file erano corretti per la mia scheda sd specialmente per questo intoppo ma adesso la riconosce e scrive il log in coordinate sulla scheda sd.
    dallo schermo invece vedo velocità altitudine e numero di satelliti che per adesso resta a zero almeno fin quando non provo in esterno.
    del numero di satelliti francamente non me ne faccio nulla, vorrei aggiungere al codice la distanza percorsa.. ho chiesto al creatore del progetto se ha qualche suggerimento, vediamo se mi risponde. :)
     
  3. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    per adesso lo sto alimentando con un esc..
    il collegamento delle varie schede è abbastanza semplice
    [​IMG] [​IMG]


    credo che avrei molto spazio su questo display per scrivere altre informazioni.. tanto per cominciare i valori attuali li vorrei avvicinare alle scritte in modi di liberare in basso.
    poi vorrei aggiungere sul display altre informazioni ad esempio: la distanza percorsa e magari anche il tempo trascorso.
    per favore avete qualche suggerimento o link per capire come operare su questi display per modificare il codice?
    posso anche fare esperimenti e vedere cosa succede..
     
  4. Rock Golem

    Rock Golem Mercante RC Photo_Pro

    Messaggi:
    1.176
    "Mi Piace" ricevuti:
    426
    Località:
    Alessandria
    E' nato un nuovo mostro. L'inarrestabile ArduWrighiZillus-Rex.
    A parte gli scherzi complimenti veramente per il tuo impegno e per l'inventiva nel tirare fuori cose sempre interessanti.
    Mi spiace in questo caso non saperti aiutare io sono ancora in alto mare con la schedina HC12
    L'unica cosa che posso dirti è di provare a vedere sul forum ufficiale di Arduino.
     
    A Dado82 e P.Bolly piace questo messaggio.
  5. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    eh.. pure io con le hc12.. sono in altissimo mare, con le mie non ne sono venuto a capo in nessun modo poi ho mollato.
    pensa che mi balenava perfino l'idea di usarle proprio per dividere in 2 stadi separati il gps dal lettore e display ma la vedo dura.
     
  6. Dado82

    Dado82 Mercante RC

    Messaggi:
    339
    "Mi Piace" ricevuti:
    127
    Sesso:
    Maschio
    Località:
    Genova
    :+1:
    Mi associo complimenti per i tuoi lavori:nice: :clap::clap::clap:
     
    Last edited: 30 Maggio 2020
  7. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    grazie.. non so nulla credetemi.

    intanto sono riuscito a far funzionare il gps.. cosa non da poco perchè fino alle 5 di stamani non dava segni di vita.
    ho cambiato qualche linea di codice e adesso funziona.
    sat è a zero perchè sono rientrato in casa.. prima dava 7 in esterno.
    sono anche riuscito a modificare l'ordinamento sul display e aggiungere un nuovo valore.. in foto non si vede a breve aggiorno.
    quello che mi manca adesso è l'istruzione corretta per calcolare distanze in chilometri ma ci sto lavorando.



    [​IMG]
     
  8. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    questo è il codice adesso come si vede in foto.

    Codice:
    #include <Wire.h>
    #include "SSD1306Ascii.h"
    #include "SSD1306AsciiWire.h"
    #include <TinyGPS++.h>
    #include <SoftwareSerial.h>
    #include<SD.h>
    
    
    
    const int cs_sd=2;
    static const int RXPin = 0, TXPin = 1;
    static const uint32_t GPSBaud = 9600;
    TinyGPSPlus gps;
    SoftwareSerial ss(RXPin, TXPin);
    
    int maxspeed = 0, speed1 = 0;
    int maxhigh = 0, high1 = 0;
    int maxsatelite = 0, satelite1 = 0;
    int dist =0, dist1=0;
    
    
    #define I2C_ADDRESS 0x3C
    
    
    #define RST_PIN -1
    
    SSD1306AsciiWire oled;
    //------------------------------------------------------------------------------
    void setup() {
      Wire.begin();
      ss.begin(GPSBaud);
    
    #if RST_PIN >= 0
      oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
    #else
      oled.begin(&Adafruit128x64, I2C_ADDRESS);
    #endif
      oled.setFont(System5x7);
      oled.clear();
      oled.println(" ");
      oled.println("GPS DATA LOGGER");
    
      delay(3000);
      oled.clear();
     
     
    
       if(!SD.begin(cs_sd))  
      {
       oled.clear();
       oled.print(" SD");
     
        return;
      }
     
        oled.print("SD OK");
    
        delay(2000);
    
       oled.clear();
      
      File data = SD.open("log.txt",FILE_WRITE);            
      data.println(""); data.println("log acquisition");  
      data.close();
    }
    //------------------------------------------------------------------------------
    void loop() {
      
        satelite1 = (abs(gps.satellites.value()));
    
        oled.print("V max ");
        oled.print(" H max   ");
        oled.print(" Sat  ");
        
      
      
      
      
    
      oled.println(" ");
      oled.println(" ");
       speed1 = (gps.speed.kmph());
      if ( speed1 > maxspeed) {
        maxspeed = speed1;
      }
    
      oled.setCursor(10 , 80);
      oled.print(maxspeed);
     
      high1 = (gps.altitude.meters());
      if ( high1 > maxhigh) {
        maxhigh = high1;
      }
      oled.setCursor(50 , 80);
      oled.print(maxhigh);
    
       oled.setCursor(100 , 80);
      oled.print(satelite1);
      oled.println(" ");
      oled.println(" ");
      oled.print(" Km ");
      oled.println(" ");
      oled.println(" ");
       dist1 = (gps.course.value());
      if ( dist1 > dist) {
        dist = dist1;
      }
      oled.setCursor(10 , 110);
      oled.print(dist1);
     
       String Temps=String(gps.time.hour()+1)+(":")+(gps.time.minute())+(":")+(gps.time.second());
      String Date=String(gps.date.day())+("/")+(gps.date.month())+("/")+(gps.date.year());
    
    
      File data=SD.open("log.txt",FILE_WRITE);
      data.println(Date + " " + Temps + " " + String(gps.location.lat(), 6)+" "+String(gps.location.lng(), 6)+(" ")+String(gps.altitude.meters(),0)+(" ")+String(gps.speed.kmph(),0))+(" ")+String(satelite1);
      data.close();
     
     
     
     
     
        DelayGPS(100);
    
     
    
    
     
      
      oled.clear();
    
      }
    
      static void DelayGPS(unsigned long ms)
    {
      unsigned long start = millis();
      do
      {
        while (ss.available())
          gps.encode(ss.read());
      } while (millis() - start < ms);
    }
    

    [​IMG]

    ho fatto funzionare il gps cambiando i pedini rx 3 tx 4 spostandoli su "1 e 0" ovvero quelli che sulla board nano hanno scritto rx e tx adesso funziona anche se lo trovo assurdo.


    sul display ho inserito la scritta relativa ai chilometri percorsi e la casella dove visualizzare il valore.
    ho iniziato a scrivere una stringa con l'ipotetica funzione per sapere la distanza ma molto probabilmente sarà sbagliata..
    penso che per ottenere un chilometraggio su strada andrà fatta una funzione float che aggiorna il valore sommando a ogni nuova misurazione.. ovviamente non la so ancora fare.
    per provare ho usato course.value dalla libreria tinygps++ ma nella migliore delle ipotesi misurerà una retta e forse allo stato attuale neanche quella..

    appena posso provo a farmi un giro e vi saprò dire..
     
    Last edited: 30 Maggio 2020
  9. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    dunque.. un piccolo aggiornamento: ho aggiunto la velocità in chilometri orari, l'unico dato visibile che adesso cambia spesso sul display.
    provato adesso per strada e funziona..
    ho aggiunto anche una scritta Trip e come il nome sottintende qui viene il bello..

    vorrei poter sommare le letture di velocità divise per 3.6 in modo da avere una progressiva crescita del dato di viaggio in metri al secondo.
    non sarà una lettura troppo precisa ma per un camioncino potrebbe bastare.
    questa è la libreria del gps http://arduiniana.org/libraries/tinygpsplus/
    la libreria permette di base di usare Serial.println(gps.speed.mps()); // Speed in meters per second (double)
    quindi si potrebbe partire da qui per fargli fare le somme..

    mi volete aiutare? non so se ancora lo saprò fare ma non demordo..


    [​IMG]

    il codice fino a dove sono arrivato adesso

    Codice:
    #include <Wire.h>
    #include "SSD1306Ascii.h"
    #include "SSD1306AsciiWire.h"
    #include <TinyGPS++.h>
    #include <SoftwareSerial.h>
    #include<SD.h>
    
    
    
    const int cs_sd=2;
    static const int RXPin = 0, TXPin = 1;
    static const uint32_t GPSBaud = 9600;
    TinyGPSPlus gps;
    SoftwareSerial ss(RXPin, TXPin);
    
    int maxspeed = 0, speed1 = 0;
    int maxhigh = 0, high1 = 0;
    int maxsatelite = 0, satelite1 = 0;
    int kmh = 0, kmh1 = 0;
    
    
    #define I2C_ADDRESS 0x3C
    
    
    #define RST_PIN -1
    
    SSD1306AsciiWire oled;
    //------------------------------------------------------------------------------
    void setup() {
      Wire.begin();
      ss.begin(GPSBaud);
    
    #if RST_PIN >= 0
      oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
    #else
      oled.begin(&Adafruit128x64, I2C_ADDRESS);
    #endif
      oled.setFont(System5x7);
      oled.clear();
      oled.println(" ");
      oled.println("GPS DATA LOGGER");
    
      delay(1000);
      oled.clear();
     
     
    
       if(!SD.begin(cs_sd))  
      {
       oled.clear();
       oled.print(" SD");
     
        return;
      }
     
        oled.print("SD OK");
    
        delay(1000);
    
       oled.clear();
      
      File data = SD.open("log.txt",FILE_WRITE);            
      data.println(""); data.println("log acquisition");  
      data.close();
    }
    //------------------------------------------------------------------------------
    void loop() {
      
        satelite1 = (abs(gps.satellites.value()));
    
        oled.print("V max ");
        oled.print(" H max   ");
        oled.print(" Sat  ");
        oled.println(" ");
      oled.println(" ");
      
      speed1 = (gps.speed.kmph());
      if ( speed1 > maxspeed) {
        maxspeed = speed1;
      }
    
      oled.setCursor(10 , 60);
      oled.print(maxspeed);
     
      high1 = (gps.altitude.meters());
      if ( high1 > maxhigh) {
        maxhigh = high1;
      }
      oled.setCursor(50 , 60);
      oled.print(maxhigh);
    
       oled.setCursor(100 , 60);
      oled.print(satelite1);
      oled.println(" ");
      oled.println(" ");
      oled.print("Km/h");
      oled.print("  Trip ");
      oled.println(" ");
      oled.println(" ");
    {
      kmh1 = (gps.speed.kmph());
     
      }
    
      oled.setCursor(10 , 110);
      oled.print(kmh1);
     
       String Temps=String(gps.time.hour()+1)+(":")+(gps.time.minute())+(":")+(gps.time.second());
      String Date=String(gps.date.day())+("/")+(gps.date.month())+("/")+(gps.date.year());
    
    
      File data=SD.open("log.txt",FILE_WRITE);
      data.println(Date + " " + Temps + " " + String(gps.location.lat(), 6)+" "+String(gps.location.lng(), 6)+(" ")+String(gps.altitude.meters(),0)+(" ")+String(gps.speed.kmph(),0))+(" ")+String(satelite1);
      data.close();
        DelayGPS(100);  
      oled.clear();
    
      }
    
      static void DelayGPS(unsigned long ms)
    {
      unsigned long start = millis();
      do
      {
        while (ss.available())
          gps.encode(ss.read());
      } while (millis() - start < ms);
    }
    
    
     
  10. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    ho aggiunto il nuovo dato dei metri al secondo.. sono le stringhe con Kmh, ora esco a provarlo per strada e vi sapro dire..
    ovviamente ancora non è un conta chilometri ma solo un indicatore di metri al secondo.
    Codice:
    #include <Wire.h>
    #include "SSD1306Ascii.h"
    #include "SSD1306AsciiWire.h"
    #include <TinyGPS++.h>
    #include <SoftwareSerial.h>
    #include<SD.h>
    
    
    
    const int cs_sd=2;
    static const int RXPin = 0, TXPin = 1; 
    static const uint32_t GPSBaud = 9600;
    TinyGPSPlus gps;
    SoftwareSerial ss(RXPin, TXPin);
    
    int maxspeed = 0, speed1 = 0;
    int maxhigh = 0, high1 = 0;
    int maxsatelite = 0, satelite1 = 0;
    int kmh = 0, kmh1 = 0;
    
    
    #define I2C_ADDRESS 0x3C
    
    
    #define RST_PIN -1
    
    SSD1306AsciiWire oled;
    //------------------------------------------------------------------------------
    void setup() {
      Wire.begin();
      ss.begin(GPSBaud);
    
    #if RST_PIN >= 0
      oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
    #else 
      oled.begin(&Adafruit128x64, I2C_ADDRESS);
    #endif 
      oled.setFont(System5x7);
      oled.clear();
      oled.println(" ");
      oled.println("GPS DATA LOGGER");
    
      delay(1000);
      oled.clear();
     
     
    
       if(!SD.begin(cs_sd))   
      {
       oled.clear();
       oled.print(" SD");
     
        return;
      }
     
        oled.print("SD OK");
    
        delay(1000);
    
       oled.clear();
       
      File data = SD.open("log.txt",FILE_WRITE);             
      data.println(""); data.println("log acquisition");   
      data.close(); 
    }
    //------------------------------------------------------------------------------
    void loop() {
       
        satelite1 = (abs(gps.satellites.value()));
    
        oled.print("V max ");
        oled.print(" H max   ");
        oled.print(" Sat  ");
        oled.println(" ");
      oled.println(" "); 
       
      speed1 = (gps.speed.kmph());
      if ( speed1 > maxspeed) {
        maxspeed = speed1;
      }
    
      oled.setCursor(10 , 60);
      oled.print(maxspeed);
     
      high1 = (gps.altitude.meters());
      if ( high1 > maxhigh) {
        maxhigh = high1;
      }
      oled.setCursor(50 , 60);
      oled.print(maxhigh);
    
       oled.setCursor(100 , 60);
      oled.print(satelite1);
      oled.println(" "); 
      oled.println(" ");
      oled.print("Km/h");
      oled.print("  Trip ");
      oled.println(" ");
      oled.println(" "); 
    {
      kmh1 = (gps.speed.kmph());
     
      }
    
      oled.setCursor(10 , 110);
      oled.print(kmh1);
      {
      kmh = (gps.speed.mps());
     }
    
      oled.setCursor(50 , 110);
      oled.print(kmh);
     
       String Temps=String(gps.time.hour()+1)+(":")+(gps.time.minute())+(":")+(gps.time.second());
      String Date=String(gps.date.day())+("/")+(gps.date.month())+("/")+(gps.date.year());
    
    
      File data=SD.open("log.txt",FILE_WRITE);
      data.println(Date + " " + Temps + " " + String(gps.location.lat(), 6)+" "+String(gps.location.lng(), 6)+(" ")+String(gps.altitude.meters(),0)+(" ")+String(gps.speed.kmph(),0))+(" ")+String(satelite1); 
      data.close(); 
        DelayGPS(100);   
      oled.clear();
    
      }
    
      static void DelayGPS(unsigned long ms)
    {
      unsigned long start = millis();
      do
      {
        while (ss.available())
          gps.encode(ss.read());
      } while (millis() - start < ms);
    }
    
     
    A pensieriusati piace questo elemento.
  11. pensieriusati

    pensieriusati Un mezzo normale? Anche no! Photo_Pro

    Messaggi:
    6.316
    "Mi Piace" ricevuti:
    1.434
    Sesso:
    Maschio
    Località:
    Vicenza
    Stai facendo un ottimo lavoro.
    Mi sa che se ci riesci te ne commissiono una :D

    E anche per quanto riguarda il movimento della testa. :D:D

    Intanto lavora! :frusta:
     
  12. Rock Golem

    Rock Golem Mercante RC Photo_Pro

    Messaggi:
    1.176
    "Mi Piace" ricevuti:
    426
    Località:
    Alessandria
    Quindi se ho capito vorresti trasformare il dato di m/s misurando anche il tempo di movimento per poi avere la distanza in metri?
    Domanda ma il display lo monti come cruscotto del mezzo per vederlo dalla cam?
     
  13. pensieriusati

    pensieriusati Un mezzo normale? Anche no! Photo_Pro

    Messaggi:
    6.316
    "Mi Piace" ricevuti:
    1.434
    Sesso:
    Maschio
    Località:
    Vicenza
    Io lo farei. :D
    Ma temo che quel display sia grandicello, per poter entrare in un cruscotto...
     
  14. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    il display è scandalosamente piccolo, misura 3cm x 1,5
    potrei anche metterlo nel cruscotto da vedere dalla cam ma credo che lo sbatterò in una scatolina da pianale. anche perchè al sole non si vede (il prossimo bianco) e comunque registra tutti i dati che vengono visualizzati sul display anche su un file.txt nella SD dove si aggiungono le coordinate ricevute.

    studiacchiando sono giunto alla conclusione che non si può misurare la distanza percorsa con una nano e un gps da modellismo.. servirebbe più memoria e una architettura a 64bit.

    quindi penso di aver sfruttato al massimo l'oggetto anche perchè la nano è pienissima.
    questo è l'ultimo codice che contiene l'orologio gps aggiornato al timezone locale.. (settabile da parametro)
    Codice:
    #include <Wire.h>
    #include "SSD1306Ascii.h"
    #include "SSD1306AsciiWire.h"
    #include <TinyGPS++.h>
    #include <SoftwareSerial.h>
    #include<SD.h>
    const int cs_sd=2;
    static const int RXPin = 0, TXPin = 1;
    static const uint32_t GPSBaud = 9600;
    TinyGPSPlus gps;
    SoftwareSerial ss(RXPin, TXPin);
    int maxspeed = 0, speed1 = 0;
    int maxhigh = 0, high1 = 0;
    int maxsatelite = 0, satelite1 = 0;
    int Mps , kmh1 ;
    int hr = 0;
    int mn = 0;
    int timezonehr = +2; //Timezone hour offset
    int timezonemn = 0;  //Timezone minute offset
    
    
    #define I2C_ADDRESS 0x3C
    
    
    #define RST_PIN -1
    
    SSD1306AsciiWire oled;
    //------------------------------------------------------------------------------
    void setup() {
      Wire.begin();
      ss.begin(GPSBaud);
    
    #if RST_PIN >= 0
      oled.begin(&Adafruit128x64, I2C_ADDRESS, RST_PIN);
    #else
      oled.begin(&Adafruit128x64, I2C_ADDRESS);
    #endif
      oled.setFont(X11fixed7x14);
      oled.clear();
    
    
    
      oled.println(" DYNAHEAD GPS UNIT");
      delay(2000);
       oled.println(" ");
     
      oled.println(" ALL TERRAIN TRUCK");
    
    
     
     
      delay(3000);
      oled.clear();
     
     
    
       if(!SD.begin(cs_sd))
      {
       oled.clear();
       oled.print("NO SD");
     
        return;
      }
     
        oled.print("SD READY");
    
        delay(1000);
    
       oled.clear();
    
     
     
      File data = SD.open("log.txt",FILE_WRITE);         
      data.println(""); data.println("log acquisition");
      data.close();
    }
    //------------------------------------------------------------------------------
    void loop() {
     
         oled.print("V max ");
        oled.print(" H max ");
        oled.print(" Sat  ");
        oled.println(" ");
     
    
     
      {
      speed1 = (gps.speed.kmph());
      if ( speed1 > maxspeed)
        maxspeed = speed1;
      oled.setCursor(10 , 30);
      oled.print(maxspeed);}
     {
      high1 = (gps.altitude.meters());
      if ( high1 > maxhigh)
        maxhigh = high1;
      oled.setCursor(50 , 30);
      oled.print(maxhigh);}
    {
      satelite1 = (abs(gps.satellites.value()));
       oled.setCursor(100 , 30);
      oled.print(satelite1);}
       oled.println(" ");
      oled.print("Km/h");
      oled.print("    M/s ");
      oled.print(" Time ");
      oled.println(" ");
     
     
    {
      kmh1 = (gps.speed.kmph());
      oled.setCursor(10 , 110);
      oled.print(kmh1);}
      {
      Mps = (gps.speed.value());
      oled.setCursor(50 , 110);
      oled.print(Mps);}
     {
      hr= (gps.time.hour());
     
    
      mn=(gps.time.minute());
      hr = gps.time.hour();
        mn = gps.time.minute();
        //hr = 0; //DEBUG
        //mn = 0; //DEBUG
        mn = mn + timezonemn;
        if (mn > 59) {
          mn = mn - 60;
          hr = hr + 1;
        }
        else {
          if (mn < 0) {
            mn = mn + 60;
            hr = hr - 1;
          }
        }
        hr = hr + timezonehr;
        if (hr > 23) {
          hr = hr - 24;
        }
        else {
          if (hr < 0) {
            hr = hr + 24;
          }
        }
        if (hr > 12) {
          hr = hr - 12;
          oled.setCursor(90 , 110);
      oled.print(hr);}
      oled.setCursor(105 ,100);
      oled.print(mn);
    }
       String Temps=String(gps.time.hour()+1)+(":")+(gps.time.minute())+(":")+(gps.time.second());
      String Date=String(gps.date.day())+("/")+(gps.date.month())+("/")+(gps.date.year());
    
    
      File data=SD.open("log.txt",FILE_WRITE);
      data.println(Date + " " + Temps + " " + String(gps.location.lat(), 6)+" "+String(gps.location.lng(), 6)+(" ")+String(gps.altitude.meters(),0)+(" ")+String(gps.speed.kmph(),0))+(" ")+String(satelite1);
      data.close();
        DelayGPS(100);
      oled.clear();
    
      }
    
      static void DelayGPS(unsigned long ms)
    {
      unsigned long start = millis();
      do
      {
        while (ss.available())
          gps.encode(ss.read());
      } while (millis() - start < ms);
    }
    
    lo potete facilmente costruire se volete con questo schema
    https://hacksterio.s3.amazonaws.com/uploads/attachments/1050601/nano_ssd1306_SnGWrOGN8i.jpg

    le uniche modifiche hardware che ho fatto sono i piedini tx rx del gps che nello sketch sono assegnati a 0-1 ovvero i pedini con scritto rx tx sulla basetta della nano e il piedino 2 che nel disegno è collegato al piedino 6
    nulla vi impedisce di assegnare i piedini del disegno e modificarli sullo schetch alle linee : static const int RXPin = 0, TXPin = 1; mettendo 3-4
    infine alla stringa const int cs_sd=2; mettendo 6, a quel punto dovrebbe funzionare come da disegno.. non ho provato però..

    i pezzi impiegati sono:
    un oled ssd1306 128x64 che su ebay costa 5 euro anche in italia
    un Lettore Sd card Writer Arduino SPI circa 1,50 euro
    una board nano atmega 328p 3-5 euro
    un gps neo6 con antenna incorporata 5-10 euro

    i collegamenti del display con la nano sono:
    SCL= A5
    SDA=A4
    + 3.3v
    - gnd

    SD card writer:
    MISO= D12
    SCK = D13
    MOSI =D11
    CS = D2
    +3,3v
    - gnd

    GPS NEO6:
    + 3,3v (verificare il voltaggio del gps altrimenti 5v)
    -gnd
    TX = RX0
    RX =TX1

    non serve a un cxx, però per didattica.. :D


    a tale propostito ora potrebbe partire il progetto per la seconda nano e medesimo tipo di display (bianco però) per indicare la distanza percorsa con un reed o un A3144 e un magnete incollato al cerchione.. :)
     
    Last edited: 2 Giugno 2020
    A pensieriusati piace questo elemento.
  15. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    e invece mi sono sbagliato...
    sto cambiando libreria del gps e con questa nuova neogps ora misuro anche i metri percorsi.. sembra più snella e precisa rispetto a tinygps++
    ho fatto un test su 150 metri e direi che ci siamo, riesco ad avere un dato abbastanza attendibile di km + decine di metri percorsi.
    a questo odometro adesso aggiungerò la velocità istantanea, l'altitudine e la velocità massima raggiunta.
    il tempo di venirne a capo in tutte le sue parti e vi posterò il nuovo sketch..
     
    A Rock Golem e pensieriusati piace questo messaggio.
  16. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    stasera ho tolto il ragno di fili provvisorio e ho messo tutto in scatola..

    [​IMG]

    [​IMG]

    [​IMG]


    da questo lato ho la porta usb del GPS.. questo vecchio ublox n6m ha la porta di programmazione separata.
    ho aggiunto anche una presa BEC spinetta rossa per entrare con una batteria.

    a lato ho riportato il led del FIX satelliti..

    il pulsante è il reset .

    [​IMG]

    sull altro lato c'è la porta SD e la usb della nano.

    [​IMG]

    il programma dentro questo gps logger è diverso dall'altro.. usa una libreria neogps che calcola automaticamente la distanza percorsa.
    ho aggiunto la velocità istantanea, la punta di velocità massima e l'altitudine che ancora non so se funziona.

    l'altitudine non è mai uscita da 0.00 ma è anche vero che non ho mai visto un FIX decente con led verde fisso, quindi potrebbe essere colpa del mio gps.
    oppure ho sbagliato qualcosa nello scrivere il codice ma prima o poi capirò il motivo..
    questo è il 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 odometer;
    float Speed;
    float High;
    int High1;
    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; // 12;
      const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
      int show          = INITIAL_SHOW;
      const int   BUZZER_PIN  = 4;
    const float SPEED_LIMIT = 0.1; //55.0; // kph
     
      int maxspeed = 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 Card");
      delay(3000);
      return;
      }
      lcd.println(" ");
      lcd.print("SD Card READY");
     
    
      delay(2000);
    
      lcd.clear();
    
      File data = SD.open("log.txt",FILE_WRITE);          
      data.println(""); data.println("log acquisition");
      data.close();
    }
    
    
    void loop()
    {
    
      if (gps.available( gpsPort )) {
    
     
       gps_fix fix = gps.read();
       show = (show + 1) % SHOW_INTERVAL;
      
       if (fix.valid.altitude)
       High = ( fix.altitude () );
    
       if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
          digitalWrite( BUZZER_PIN, HIGH );
          Serial.println( F("Too fast!") );
       } else {
          digitalWrite( BUZZER_PIN, LOW );
       }
    
     
       if (fix.valid.location) { // && fix.valid.speed && (fix.speed_kph() > MIN_SPEED)
       if (lastLocOK) {
       odometer += fix.location.DistanceKm( lastLoc );
       Speed = fix.speed_kph();
    
    
      }
    
      lastLoc   = fix.location;
      lastLocOK = true;
      }
    
      if ( Speed > maxspeed)
      maxspeed = Speed;
      
      if (High > High1)
      High1 = High;
     
     
      if (show == 0) {
    
      #define MAX_CHARS 22
      char displayBufffer[MAX_CHARS];
    
      lcd.setCursor(0,0);
      
      
      snprintf(displayBufffer, MAX_CHARS, " Km  :  %  3d.%02d", (int)odometer, (int)(odometer * 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)maxspeed, (int)(maxspeed * 100)%100);
      lcd.println(displayBufffer);
    
      snprintf(displayBufffer, MAX_CHARS, " Alt   :  %  3d.%02d", (int)High, (int)(High * 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(fix.altitude_ft())+(" ")+String(fix.speed_kph(),0));
      data.close();
      }
      if ((show == INITIAL_SHOW) && (millis() > 2000)) {
    
      if (gps.statistics.chars == 0) {
      lcd.clear();
      lcd.println(F("No data from GPS"));
    }
    }
    }
    
    ho fatto qualche prova in giardino e quando lo spostamento è continuo la distanza percorsa è abbastanza fedele.. se mi fermo con molte pause il dato si scarica lentamente e quindi si somma alla distanza percorsa.
    per esempio 15 minuti fermo sul pianerottolo mi ha aggiunto 20 metri alla distanza percorsa.


    vorrei scrivere meglio la parte che riguarda la SD al momento è un pò trascurata con tutti valori attaccati dovuto a un probabile scritto maldestro e come prima linea di testo non ha ancora una legenda dei valori descritti.
    se volete partecipare, correggere, modificare, proporre... vi ringrazio
     
    Last edited: 5 Giugno 2020
    A pensieriusati piace questo elemento.
  17. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    aggiornamento:
    il codice è corretto, l'altitudine viene misurata..
    era il mio gps ad aver bisogno di essere configurato a modino..

    quindi confermo che l'attuale codice misura l'altitudine e pure corretta visto che già conosco il dato intorno a 48 metri slm

    [​IMG]


    adesso rimane solo da sistemare la legenda nella scrittura del log.txt per descrivere i dati raccolti..

    funziona tutto e pare davvero molto bene. :)
    adesso posso portare a giro la scatolina sui miei camion collegandola alla batteria o alla porta usb (sul Dynahead ) sarebbe anche interessante aggiungere un display in cabina e riportare i dati anche nella vista fpv se non alro per capire di quanti metri ci stiamo spostando e a quale velocità.. sembra sempre di andare fortissimo e lontanissimo, magari non hai fatto ancora 30 metri e vai a 2 :D
     
    A Rock Golem e pensieriusati piace questo messaggio.
  18. pensieriusati

    pensieriusati Un mezzo normale? Anche no! Photo_Pro

    Messaggi:
    6.316
    "Mi Piace" ricevuti:
    1.434
    Sesso:
    Maschio
    Località:
    Vicenza
    Vero, ti pare di aver fatto chilometri di corsa, alzi lo sguardo e il mezzo è ancora bene in vista :D

    Quindi l'ultimo sketch è corretto?
    Se sì, quasi quasi lo scarico e provo a prendere gli ingredienti.
    Mi pare che tu li abbia messi.

    A quanto va alimentato il tutto?

    Edit: saresti capace di tradurre il codice in python?
     
  19. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    lo alimenti anche dalla usb se vuoi..
    il gps solitamente viene alimentato a 3.3v idem tutti gli altri pezzi quindi diciamo che il progetto lo alimenti da 3.3v in poi..

    il mio gps invece ha l'alimentazione a 5v e non sono stato a mettere nessuna correzione nel disegno proprio perchè è un caso particolare, ho preso il +5v del gps dalla porta 5v della nano.

    la nano dal piedino vin sembra che si alimenti fino a 12v 9v per stare sicuri, quindi anche diretto alla batteria 2s.

    l'ultimo sketch è corretto.. manca solo una sistemata alla legenda dei dati raccolti su SD a breve vedo se riesco a sistemare anche quella.

    python non ho idea, sono a malapena in grado di scrivere quello che vedi :rolleyes:

    i pezzi sono 4 salvo che non decidi di aggiungere ad esempio 1-2 celle li-ion direttamente nella scatola del progetto, in quel caso ti serve anche una schedina di ricarica.

    il progetto puoi anche farlo più piccolo del mio se prendi una scheda spi SD per le microSD.

    riassumendo i pezzi sono questi, cercatevi l'offerta migliore o un negozio che abbia direttamente tutti i pezzi da spedire, questi sono link presi a casaccio su ebay solo per descrivere i pezzi:

    nano board.
    https://www.ebay.it/itm/Nano-ATmega...123829?hash=item3ad89ac135:g:De8AAOSwKKZeND2X

    sd card grande
    https://www.ebay.it/itm/Modulo-lett...035664?hash=item4b5d9bc090:g:X5YAAOSwyttZx9Qu

    oppure a scelta Micro SD card
    https://www.ebay.it/itm/Modulo-Micr...318103?hash=item2aab861717:g:uugAAOSwzHRbG-ng

    oled blu (meglio bianco credetemi..)

    https://www.ebay.it/itm/0-96-I2C-II...734003?hash=item2cc5a8c8b3:g:PkQAAOSwLQpZqQ8x

    oppure bianco

    https://www.ebay.it/itm/0-96-I2C-II...699203?hash=item2cc5a840c3:g:uq4AAOSw8iJZqQCf

    un gps u-blox GY-NEO 6m o superiore

    https://www.ebay.it/itm/GY-NEO-6M-V...hash=item3f7cdce4cf:m:m4NWiHDOOAUgIhTbi5GJZ2A

    per il resto serve una mazzetta di fili colorati e seguire lo schema iniziale della loggerstation

    https://hacksterio.s3.amazonaws.com/uploads/attachments/1050601/nano_ssd1306_SnGWrOGN8i.jpg

    l'unica accortezza su questo schema proposto è quella di capire cosa si definisce sullo sketch e a quali piedini si assegnano i relativi fili..
    per esempio lui ha disegnato il filo CS al piedino 6 ma poi nel suo sketch lo assegna al piedino 2
    idem io ho scritto lo sketch adesso col gps assegnato ai piedini 4-5 mentre sullo schema li assegna ai piedini 2-3 quindi a tua scelta se correggere i numeri dello sketch oppure se spostare i fili sulla nano.

    vedi questo schema che ho disegnato, corrisponde all'attuale sketch col gps collegato ai piedini 4-5


    credo di aver descritto tutto abbastanza chiaramente

    [​IMG]

    i gnd (negativo) li collegate tutti assieme o li smistate tra i 2 gnd presenti sulla nano.
    i vcc vanno tutti al piedino 3.3v + gps compreso nella maggior parte dei casi.
    vin ci collegate la batteria +
    al pulsante reset (normalmente aperto) è assegnato il piedino reset sulla nano, potete pure evitare di metterlo se vi ingegnate per premere quello già presente sulla nano.
    la SD card almeno la mia ha 2 gnd io li ho usati entrambi per smistare i negativi senza dover saldare mazzetti di fili uniti assieme..

    ricordatevi di incrociare rx tx tra nano e gps come da colori del disegno.

    lo sketch lo potete anche un pochino personalizzare cambiando caratteri o aggiungendo testo, nei limiti .. nel caso se ne parla.. per esempio "welcome gps logger" l'ho scritto io.. idem il testo accanto ai valori ma cambiando testo e caratteri andrà anche un pochino sistemata l'impaginazione sul display.

    ah.. in questo sketch è presente anche una funzione nascosta che permette di far suonare un buzzer arrivato a 55kmh io l'ho lasciata e non me ne sono curato perchè era già presente nello sketch da quale sono partito.. nel caso potete aggiungere un cicalino oppure un led che vi avverte quando avrete superato una certa velocità.
     
    Last edited: 5 Giugno 2020
    A pensieriusati piace questo elemento.
  20. wrighizilla

    wrighizilla Mercante RC

    Messaggi:
    648
    "Mi Piace" ricevuti:
    491
    Località:
    Firenze
    alla fine non c'è più motivo di usare lo sketch iniziale di loggerstation che usa la libreria tinygps++ perchè funziona peggio e si vede il loop dallo schermo con la banda nera che passa ogni tot..

    questo basato su neogps è molto più preciso e il testo è fisso senza flickering grazie alle funzioni scritte sul display assegnando max_chars e snprintf
    un pò complicato, mi è toccato studiare per capirci qualcosa ma il risultato merita.
    adesso esco a testarlo per una passeggiata e vediamo cosa succede..
     
    A pensieriusati piace questo elemento.
  1. Questo sito utilizza i cookies per personalizzare i contenuti, la navigazione e la tua esperienza nell'utilizzo del forum; inoltre se decidi di registrarti, vengono utilizzati per mantenerti loggato
    Continuando ad utilizzare il sito, acconsenti all'utilizzo dei cookies.
    Nascondi Avviso