«

»

Nov 11

Stampa Articolo

Gps Tracker arduino – lo sketch

Dopo una settimana di sperimentazioni e test ho finalmente ultimato ed ottimizzato lo sketch che ti propongo.

gps tracker arduino lato

In questa settimana ho anche provveduto ad acquistare una antenna estarna ed un adattatore per migliorare il segnale ricevuto dai satelliti perché durante i miei esperimenti in laboratorio mi sono reso conto che l’antenna installata sulla Gps shield in taluni condizioni si rilevava insufficiente:

gps antenna

l’adattatore necessario per collegare questo tipo di antenna alla Gps Shield è questo:

interface cable gps

Gps Tracker arduino kit

Al termine dei miei esperimenti ho deciso di trasformare questo progetto in un kit che puoi acquistare direttamente dal sito robotics-3d.com.

  • Il kit puoi acquistarlo solo come componenti elettronici:
  • arduino uno
  • gps shield
  • adattatore SMA per antenna Gps
  • antenna Gps
  • display 20×4 I2C
  • 4 wire femmina/maschio per collegare il display alla centralina

ed in aggiunta richiedere il case tagliato a laser a cui aggiungere la viteria per il montaggio.

gps tracker arduino fronte

Lo sketch

Come ti ho promesso nel titolo ecco lo sketch del Gps Tracker arduino che ho ottimizzato per il progetto partendo da uno degli esempi inclusi nella libraria rilasciata dal produttore della shield gps: adafruit.

#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>
#include <SPI.h>
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
#include <SdFat.h>

/***************************************************************************/

#define GPSECHO true
#define SD_CS    10 

/***************************************************************************/

SoftwareSerial mySerial( 8,7 );
Adafruit_GPS GPS(&mySerial);

/***************************************************************************/

boolean usingInterrupt = false;

/***************************************************************************/

SdFat SD;
File logfile;

/***************************************************************************/

LiquidCrystal_I2C lcd(0x20,20,4);

/***************************************************************************/

void setup() {
  if ( GPSECHO ) { Serial.begin(115200); }
  
  /***************************************************************************/
  
  lcd.init();
  lcd.print(F("GPS Tracker"));
  lcd.backlight();
  lcd.setCursor(0,1);
  
  /***************************************************************************/
  pinMode(SD_CS, OUTPUT);
  if (!SD.begin(SD_CS)) {
    if ( GPSECHO ) { Serial.println(F("SD card failed!")); }
    lcd.print(F("SD .. failed!"));
    return;
  }
  if ( GPSECHO ) { Serial.println(F("SD card ... success")); }
  lcd.print(F("SD card ... success"));
  
  /***************************************************************************/
  
  GPS.begin(9600);                                
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ);
  GPS.sendCommand(PMTK_API_SET_FIX_CTL_1HZ);
  GPS.sendCommand(PGCMD_ANTENNA);            
  useInterrupt(true);                            

  /***************************************************************************/

  lcd.setCursor(0,3);
  lcd.print(F("www.mauroalfieri.it"));
  
  /***************************************************************************/

  delay(3000);
  lcd.clear();

  /***************************************************************************/
}

/***************************************************************************/

// Interrupt is called once a millisecond, looks for any new GPS data, 
// and stores it
SIGNAL(TIMER0_COMPA_vect) {
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  if (GPSECHO ) { if (c) UDR0 = c; }
}

void useInterrupt(boolean v) {
  if (v) {
    // Timer0 is already used for millis() - we'll just interrupt somewhere
    // in the middle and call the "Compare A" function above
    OCR0A = 0xAF;
    TIMSK0 |= _BV(OCIE0A);
    usingInterrupt = true;
  } else {
    // do not call the interrupt function COMPA anymore
    TIMSK0 &= ~_BV(OCIE0A);
    usingInterrupt = false;
  }
}

/***************************************************************************/

void loop() {
  if (GPS.newNMEAreceived()) {
    char *stringptr = GPS.lastNMEA();
    char *str;

    char *data;
    char *ora;
    char *longitude;
    char *longitudeC;
    char *latitude;
    char *latitudeC;
    
    byte counter = 0;
    boolean ctrl = false;
      
    if (!GPS.parse(stringptr))  return;

    if (strstr(stringptr, "RMC") || strstr(stringptr, "GGA")) {  
      /***************************************************************************/
      
      logfile = SD.open("dati.log", FILE_WRITE);
      if (logfile) { logfile.println( stringptr ); logfile.close(); }
      
      /***************************************************************************/
      
      if ( GPSECHO ) { Serial.print( stringptr ); }

      counter = 0;
      while ((str = strtok_r(stringptr, ",", &stringptr)) != NULL) {
        if ( counter == 2 && strstr(str, "A") ) ctrl = true;
        
        if ( counter == 1 ) { ora = str; }
        if ( counter == 3 ) { latitude = str;   }
        if ( counter == 4 ) { latitudeC = str;  }
        if ( counter == 5 ) { longitude = str;  }
        if ( counter == 6 ) { longitudeC = str; }
        if ( counter == 9 ) { data = str; }
        counter++;
      }

      if ( ctrl && data != "" && ora != "" && longitude != "" && 
           latitude != "" && longitudeC != "" && latitudeC != "") {
        if ( GPSECHO ) { 
          Serial.print( F("\nScrivo:\n") );
          Serial.print( F("data:") );    Serial.println( data );
          Serial.print( F("ora: ") );    Serial.println( ora );
          Serial.print( F("long:") );    Serial.println( longitude );
          Serial.print( F("lat: ") );    Serial.println( latitude );
          Serial.print( F("lonC:") );    Serial.println( longitudeC );
          Serial.print( F("latC:") );    Serial.println( latitudeC );
          Serial.println( F(" --- --- --- ") );  
        }
        
        lcd.clear();
        lcd.setCursor(0,0);   lcd.print( data[0] );
        lcd.setCursor(1,0);   lcd.print( data[1] );
        lcd.setCursor(2,0);   lcd.print( F("/") );
        
        lcd.setCursor(3,0);   lcd.print( data[2] );
        lcd.setCursor(4,0);   lcd.print( data[3] );
        lcd.setCursor(5,0);   lcd.print( F("/") );
        
        lcd.setCursor(6,0);   lcd.print( F("20") );
        lcd.setCursor(8,0);   lcd.print( data[4] );
        lcd.setCursor(9,0);   lcd.print( data[5] );
        
        lcd.setCursor(12,0);  lcd.print( ora[0] );
        lcd.setCursor(13,0);  lcd.print( ora[1] );
        lcd.setCursor(14,0);  lcd.print( F(":") );

        lcd.setCursor(15,0);  lcd.print( ora[2] );
        lcd.setCursor(16,0);  lcd.print( ora[3] );
        lcd.setCursor(17,0);  lcd.print( F(":") );

        lcd.setCursor(18,0);  lcd.print( ora[4] );
        lcd.setCursor(19,0);  lcd.print( ora[5] );

        lcd.setCursor(0,1);   lcd.print( F("lat: ") );
        lcd.setCursor(6,1);   lcd.print( latitude );
        lcd.setCursor(19,1);  lcd.print( latitudeC );

        lcd.setCursor(0,2);   lcd.print( F("lng: ") ); 
        lcd.setCursor(6,2);   lcd.print( longitude );
        lcd.setCursor(19,2);  lcd.print( longitudeC );
        
        lcd.setCursor(0,3);   lcd.print( F("www.mauroalfieri.it") );
        
      } else {
        lcd.clear();
        lcd.setCursor(0,1);   lcd.print( F("lat: ") );
        lcd.setCursor(6,1);   lcd.print( F("0000.000000  ") );
        lcd.setCursor(0,2);   lcd.print( F("lng: ") );
        lcd.setCursor(6,2);   lcd.print( F("0000.000000  ") );
      }
    }
  }
}

Il primo passo, come al solito in questo tipo di progetti è procurarti le librerie necessarie che sono elencate nella prima parte dello sketch dalla linea 001 alla 006: in particolare oltre alla libreria Adafruit_Gps ti occorre anche la SoftwareSerial per comunicare con la gps shield attraverso i pin 7 ed 8 in simulazione seriale. Le altre librerie servono a comunicare con la SD card e con il display i2c;

linee 010-011: definisci una prima costante GPSECHO destinata ad attivare o disattivare il debug seriale verso il Pc, ed una seconda SD_CS che indica il pin di CS usato dalla SD Card per scrivere i dati;

linee 015-016: inizializza un oggetto myserial che apre la comunicazione, simulata, sui pin 7 ed 8 e lo passi come argomento all’oggetto gps inizializato alla linea 016;

linea 020: definisci una variabile di tipo boolean il cui valore servirà a definire se utilizzare o non utilizzare l’interrupt;

linee 024-025: definisci un oggetto SD per la comunicazione con la SD Card ed un oggetto logfile di tipo File che utilizzerai per scrivere le righe di log in un file sulla SD Card;

linea 029: inizializza l’oggetto lcd con cui comunicherai con il display LCD sull’indirizzo 0x20 ( leggi gli articoli sull’I2C scanner per trovare l’indirizzo del tuo display ) da 20 colonne e 4 righe;

linea 034: nella funzione setup se è definita la costante GPSECHO, vedi linea 010, attivi la comunicazione seriale verso il Pc a 115200 baud;

linee 038-041: attiva la comunicazione verso il display LCD e scrivi sulla prima linea “Gps Tracker”, attiva la retroilluminazione del display e posizionati alla riga 1 ossia la riga successiva del display;

linee 044-051: sone le consuete linee necessarie alla libreria SDFat per verificare la presenza di una SD card inserita e prepararsi alla scrittura di un file su di essa;

linee 055-060: definisci la comunicazione con la gps shield a 9600 baud, valore indicato dal costruttore della shield, e invia alcuni comandi per la corretta sincronizzazione dei dati, in particolare:

PMTK_SET_NMEA_OUTPUT_RMCGGA: imposta il tipo di output da parte del GPS in formato NMEA con codifica RMC e GGA ( sul sito Adafruit trovi tutte le definizioni e psecifiche di questo formato )

PMTK_SET_NMEA_UPDATE_1HZ: imposta l’aggiornamento dei dati a 1Hz ossia 1 al secondo;

PMTK_API_SET_FIX_CTL_1HZ: imposta il controllo sulla qualità del dato ricevuto, ossia il fix, ad in 1Hz come per l’update;

PGCMD_ANTENNA: indica al Gps che è presente una antenna esterna e che vuoi utilizzarla per migliorare la ricezione;

infine richiama la funzione useInterrupt passandole il valore true;

linee 064-065: scrivi sulla 4° linea del display “www.mauroalfieri.it”;

linee 069-070: attendi 3 secondi e pulisci il display prima di terminare la funzione setup();

linee 077-097: sono riportate identiche a come impostate dal produttore della shield e contengono la funzione useInterrupt che agisce sui registri del microcontrollore arduino;

linea 102: verifichi che siano arrivati dei dati in formato NMEA nell’oggetto Gps, questo perché l’interrupt si occupa di richiamare i dati dall’antenna Gps con la regolarità che hai impostato nelle linee 055-060 e solo quando i dati sono consistenti diventano disponibili per l’elaborazione;

linea 103: recupera l’ultima ricezione dati dal Gps Tacker arduino e assegnala alla variabile stringptr per le successive elaborazioni;

linee 104-111: definisci altre variabili di tipo char in cui memorizzerai i valori letti dal Gps prima di memorizzarli nella SD e mostrarli a video;

linee 113-114: definisci una variabile di controllo ctrl di tipo boolean ed un contatore che userai tra poco;

linea 116: passa il contenuto ricevuto dal Gps al metodo parse della libreria GPS di Adafruit per verificare ch i dati siano anche sintatticamente corretti, se non lo sono retituisce un false e questo causa il return, ossia l’uscita da questo ciclo loop() per passare ad un successivo;

linea 118: siccome i dati ricevuti nel formato NMEA sono molti ma a te interessano solo quelli di tipo RMC e GGA verifica che in ciascuna stringa ricevuta dal gps ci sia il termine RMC oppure GGA e scarta gli altri valori;

linee 121-122: apri il file “dati.log” e scrivi la linea gps corrente, in particolare nel file troverai sia i dati RMC sia i dati GGA per poterli elaborare successivamente;

linea 126: se definita la costante GPSECHO scrivi sul monitor seriale la stringa ricevuta dal Gps Tracker arduino;

linee 128-139: in questo blocco di linee fai un lavoro molte semplice scomponi la linea ricevuta in singole stringhe ciascuna separata dalla “,” e seguendo lo schema rilasciato da Adafruit ( vedi link in alto ) sul tipo di codifica impari a leggere questa linea tipo:

$GPRMC,194509.000,A,4042.6142,N,07400.4168,W,2.03,221.11,160412,,,A*77

in cui ogni posizione ha un significato preciso: partendo dalla posizione 0 = $GPRMC indica il tipo di messaggio, fino all’ultima posizione. Io ho estratto solo i valori che mi interssa visualizzare sul display ossia le posizioni:

  • 1 – ora
  • 2 – carattere di controllo
  • 3 – latitudine
  • 4 – segno della latitudine ( N o S )
  • 5 – longitudine
  • 6 – segno della longitudine ( E o W )
  • 9 – data corrente da satellite

devo avvisarti subito che l’ora è riferita a Greenwich ossia il meridiamo 0° per cui rispetto a noi che siamo GMT + 1 ( Greenwich + 1 ) l’ora che visualizzi è un ora indietro;

linee 141-142: ho diviso la condizione di if su due linee per comodità, questo if determina se tutte le variabili “data,ora,longitudine,latitudine,ctrl,… ” sono correttamente valorizzate ed è quindi possibile procedere alla visualizzazione dell’informazione sul display;

linee 143-152: se la GPSECHO è definita scrivi sul monitor seriale i valori letti dal Gps ed elaborati alle linee precedenti;

linea 154-186: scrivi sul display i valori letti ed elaborati come visibile in foto:

gps tracker arduino on

linee 189-193: se il gps dovesse perdere il segnale o i dati non dovessero arrivare più in modo consistente il display visualizzerà solo:

lat:  0000.000000
lng: 0000.000000

fino al recupero dei dati Gps corretti; sulla SD Card troverai i valori letti dal Gps anche se non visualizzati dal display.

Permalink link a questo articolo: http://www.mauroalfieri.it/elettronica/gps-tracker-arduino-lo-sketch.html

24 comments

1 ping

Vai al modulo dei commenti

  1. Alessandro

    Ciao Mauro,
    Inutile dirlo, come al solito un mega grazie per l’aiuto che fornisci a noi utenti inesperti!
    In attesa che mi arrivi la shield gps, vorrei studiarmi per bene lo sketch, poiché vorrei adattarlo al mio progetto.
    Non capisco in quale punto avviene la scrittura del file sulla sd e come è strutturato il file stesso.
    Potresti spiegarlo?!?
    Grazie ancora,
    Ciao,
    Ale

    1. Alessandro

      Come non detto, ho appena letto l’articolo successivo ora mi è più chiaro!

      1. Mauro Alfieri

        Bene Alessandro.

    2. Mauro Alfieri

      Ciao Alessandro,
      la costruzione e scrittura della linea avviene tra la linea 118 e 139.
      Su come avvenga ti consiglio la lettura degli articoli dedicati alla SD Card ed alla composizione delle stringhe, non riscrivo cosa già scritte perché rischio solo di ripetermi e creare confusione.

  2. alessandro

    ciao mauro,
    oggi mi è arrivata la shield ed ho fatto una prova veloce, usando il tuo sketch. ho tolto la parte relativa all’lcd, perchè non l’ho collegata. però sul monitor seriale, visualizzo solo una stringa gpgga, in cui identifico solo un valore che penso sia un tempo gps, poi solo virgole che separano spazi vuoti. una sola linea, poi si blocca.
    ora rileggendo il codice, ho visto che hai usato l’antenna esterna, che io non ho messo. potrebbe essere che devo commentare la linea 59?
    riproverò domani, adesso ho chiuso tutto, ma se hai altri suggerimenti te ne sarei grato!

    1. Mauro Alfieri

      Ciao Alessandro,
      l’antenna aggiuntiva aiuta ma se la shield non riceve i dati corretti cambia poco.
      Nell’articolo trovi il link ad una guida di adafruit, produttore della scheda, che ti spiega il significato dei codici che ti arrivano.
      Come primo sketch ti consiglio uno di quelli di test della libreria ufficiale del produttore per comprendere bene cosa ti viene restituito dalla shield senza filtri dovuti al mio sketch.

  3. Alessandro

    Grazie Mauro, preciso come sempre.
    Alla fine il problema era che lo switch presente sulla scheda era impostato su direct connect, mentre andava messo su software serial.
    Ora tutto funziona!
    Vorrei integrare la scheda in un progetto che prevede anche un sensore che comunica via seriale sui pin 11 e 12.
    Letti separatamente, gps e Sensore, funzionano benissimo, ma lo sketch che prevede la lettura contemporanea mi dà problemi, ovvero il sensore non viene letto per niente.
    Allora mi è venuto un dubbio, sarà possibile fare quanto richiedo, oppure troppo esoso in termini di risorse?
    Il sensore trasmette in streaming a 2 hz. Ho impostato la scrittura dei dati gps e del sensore ogni 2 secondi, però la lettura deve avvenire in continuo.

    1. Mauro Alfieri

      Ciao Alessandro,
      immagino che tu stia cercando di usare due volte la Software serial, una per il GPS ed una per il sensore.
      Se così è ti invito a leggere come funziona questa libreria, ti renderai facilmente conto che usano dei TIMER ( cerca nel blog cosa sono ) e che le due comunicazioni si sovrappongono.
      Ti consiglio di usare la odalità nativa per il GPS ( più veloce e preciso ) e la SoftwareSerial.h per il sensore.

      1. Alessandro

        esatto, mauro, ho dichiarato 2 oggetti mediante:

        SoftwareSerial sensor_serial(2, 3);
        SoftwareSerial gps_serial(8, 7);

        ma mi pare di capire che il problema è proprio questo! oltre alla mia inesperienza, ovviamente!
        ora cerco le informazioni che mi hai suggerito, speriamo di riuscire a risolvere!
        quello che vorrei fare è registrare su una sd una stringa contenente la posizione gps e il dato registrato dal sensore, essendo tutto il sistema in movimento. quindi creo una sorta di “mappa” del dato registrato dal sensore.

        1. Mauro Alfieri

          Ciao Alessandro,
          pensi che il problema sia la doppia inizializzazione di una istanza della SoftwareSerial.
          Controlla nel reference sul sito arduino.cc se è possibile usarla in questo modo.

      2. Alessandro

        rieccomi di nuovo qua! mi sono un po’ documentato… prima di tutto come hai consigliato, ho spulciato tutta la sezione relativa alla libreria SoftwareSerial, ma non ho trovato indicazioni sui timer 🙁
        poi ho cercato informazioni su quella che chiami “modalità nativa”, che se ho capito bene, dovrebbe essere quella descritta a questo [url=https://learn.adafruit.com/adafruit-ultimate-gps-logger-shield/direct-connect]link[\url], giusto?
        in effetti così facendo, appena apro il monitor seriale, vedo scorrere le stringhe GPGGSA e GPRMC, in cui ci sono i dati che mi interessano. se mi confermi che questa è la strada che mi stavi suggerendo, allora vado avanti a studiare questo collegamento!
        in pratica, dovrei “intercettare” le stringhe GPGGA (supponiamo al momento che mi interessi solo quella) e scriverla sul log file nella SD, assieme ai dati del sensore, che arriveranno dalla SoftwareSerial, giusto?!?
        scusami se ti faccio mille domande, ma vorrei capire bene, prima di addentrarmi in faccende complicate!

        grazie ancora e ciao!

        1. Mauro Alfieri

          Ciao Alessandro,
          per “modalità nativa” intendevo la connessione diretta della shield Gps con i pin Tx, pin 1, ed Rx, pin 0.

          1. Alessandro

            ok, allora avevo capito bene!
            funziona, in effetti vedo le stringhe scorrere sul monitor seriale, appena lo apro!
            il problema, adesso, è che non so come “leggerle”, per poterle usare nello skecth…

          2. Mauro Alfieri

            Ciao Alessandro,
            le leggi nello stesso modo con cui le leggevi con la SoftwareSerial, solo che usi i comandi della Serial e non della SoftwareSerial.
            Dovrei aver dedicato uno o più articoli alle differenze nel mio corso base arduino gratuito on-line.

  4. Alessandro

    ciao mauro, scusa se insisto, ma non ne sono ancora venuto a capo… vorrei spiegarti in breve cos’ho fatto.
    se metto il gps in modalità “software serial” ed utilizzo la libreria SoftwareSerial, tutto funziona perfettamente. leggo dalla mySerial (8,7) le stringhe che il gps manda fuori e riesco anche ad isolarle, prendendo solo alcuni campi di mio interesse, dalla stringa GPGGS. ho utilizzato a tal fine le funzioni substring e nidexof della classe String. fin qua tutto bene.
    però il mio problema è che ho un altro sensore che utiliza la software serial, quindi adesso devo mettere il gps in modalità “direct connect”, altrimenti non posso usare 2 software serial.
    allora, una volta messo il gps in “direct connect”, vedo le stringhe scorrere sul monitor seriale, ma non riesco a leggerle. quello che ho fatto è semplicemente sostituire nel mio sketch mySerial con Serial, come hai suggerito, ma sembra non funzionare. già se metto un output di controllo dopo “if (Serial.available())”, non succede niente, come se appunto non fosse “available”!
    non so se mi sono spiegato… riassumendo, mi servirebbe un aiuto per leggere le stringhe che appaiono sul monitor seriale, dopo aver messo il gps in modalità “direct connect”!
    grazie!

    1. Mauro Alfieri

      Ciao Alessandro,
      purtroppo non conosco bene il tuo modello di GPS shield e posso solo ipotizzarne il funzionamento.
      Le istruzioni corrette le devi verificare sulla documentazione del produttore; da quanto mi scrivi sembra che la velocità di comunicazione ( baud ) del “direct connect” sia differente dalla velocità utilizzata dalla SoftwareSerial.
      Se la mia ipotesi fosse corretta ti basta impostare nel begin della Serial la velocità giusta.

      Se vuoi comprendere meglio il discorso prova a cercare sul web come funziona una comunicazione seriale è semplice ma spiegarlo non è possibile in un commento.

      1. Alessandro

        ciao!
        la mia shield è esattamente uguale alla tua!
        comunque alla fine sono riuscito a far funzionare (quasi) tutto, in modalità software serial, facendo partire e stoppando le comunicazioni in modo alternato!

        1. Mauro Alfieri

          Ottimo Alessandro !!!

  5. Gianluca

    Ciao,
    Ho letto il vostro interessante scambio. Vorrei sapere se e’ possibile e come fare per leggere due dispositivi seriali con la stessa software serial (Alessandro ha detto che ha fatto partire e stoppato le due comunicazioni seriali in modo alternato).
    Grazie !

    1. Mauro Alfieri

      Ciao Gianluca,
      lascio on-line il tuo commento perché possa intervenire Alessandro spiegandoti il metodo usato.

  6. Michele

    Mi da questo messaggio di errore quando verifico lo sketch, cosa mi consigli di fare?

    Arduino:1.8.2 (Windows 10), Scheda:”Arduino/Genuino Uno”

    C:\Users\Utente\Desktop\sketch_may24a\sketch_may24a\sketch_may24a.ino:1:26: fatal error: Adafruit_GPS.h: No such file or directory

    #include

    ^

    compilation terminated.

    exit status 1
    Errore durante la compilazione per la scheda Arduino/Genuino Uno.

    Questo report potrebbe essere più ricco di informazioni abilitando l’opzione
    “Mostra un output dettagliato durante la compilazione”
    in “File -> Impostazioni”

    1. Mauro Alfieri

      Ciao Michele,
      come descritto nelle linee di spiegazione dello sketch, che ti invito a leggere e comprendere prima di realizzare il progetto, devi caricare tutte le librerie indicate nello sketch dalla line a 1 alla 6.
      Trovi molti tutorial in internet che ti descrivono come fare.

  7. Michele

    Ho risolto quasi tutti i problemi, soltanto che dopo aver stampato a video “GPS Tracker” e “SD success” lo schermo viene ripulito e non viene più stampato niente. Ho provato a mettere un delay di 3 sec credendo che lo sketch stampasse talmente veloce che lcd non riusciva visualizzarlo, ma ancora niente. Inoltre ho visto che sulla SD non viene salvato alcun dato.

    1. Mauro Alfieri

      Ciao Michele,
      probabilmente lo sketch non riesce ad inizializzare il GPS.
      Se leggi lo sketch la linea successiva al “SD success” carca di inizializzare la conessione con il Gps ( linea 55 ) se questa o le successive non riescono a comunicare con il gps si blocca.
      Verifica che funzioni il gps con uno sketch di esempio fornito dal produtore, se è il medesimo del mio articolo, puoi usare gli esempi Adafruit.

  1. Gps Tracker arduino dati - Mauro Alfieri Maker Domotica Robot

    […] « Gps Tracker arduino – lo sketch […]

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Puoi usare i seguenti tag ed attributi HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>