• 1
  • info@lungolagocapodimonte.it

    GPS Shield Arduino Uno Duemilanove - Interfacciare Arduino con i ricevitori GPS utilizzando l'apposito GPS Shield e facciamo le nostre prime esperienze con la localizzazione da satellite.

    GPS Shield Arduino Uno Duemilanove - Interfacciare Arduino con i ricevitori GPS utilizzando l'apposito GPS Shield e facciamo le nostre prime esperienze con la localizzazione da satellite

     

     

    GPS Shield con Arduino Uno / Duemilanove

    Questa volta ci occupiamo della interessantissima tecnologia GPS per la rilevazione della posizione sul globo terrestre (Global Position System). Come saprete sopra le nostre teste, a circa 20.000 km, sono posizionati dei satelliti che inviano costantemente sulla terra una serie di informazioni; queste, opportunamente captate ed elaborate, ci permettono di determinare la nostra posizione. Per ricevere ed analizzare i dati serve un GPS receiver completo di antenna, il quale, dopo essersi agganciato al segnale dei satelliti, fornisce sulla sua uscita una stringa di caratteri ASCII contenenti, oltre alla posizione, importanti dati.

    Il ricevitore GPS deve ovviamente essere nella condizione di ricevere segnali dallo spazio e quindi non funziona in ambienti chiusi come abitazioni o gallerie; inoltre, come tutti gli apparati radio operanti a microonde, riceve male in presenza di palazzi o costruzioni di grandi dimensioni, dato che a tali frequenze la propagazione del segnale è quasi in linea retta. Se la ricezione è buona, dopo l'accensione serve un tempo di acquisizione (denominato fixing) di solito

    compreso tra 30 secondi e 1 minuto, dopo cui il ricevitore passa alla fase di tracciamento, nella quale fornisce la posizione.

    Per chi volesse approfondire l'aspetto teorico di questa tecnologia suggeriamo di leggere "Tecnologia ed apparati GPS" - VISPA edizioni. La sequenza dei dati in uscita è

    composta da semplici caratteri ASCII codificati nella sentenza NMEA e contiene, oltre alla longitudine e latitudine del ricevitore anche l'altezza sul mare, la data e l'ora e le indicazioni dei satelliti agganciati. Oggi giorno il mercato fornisce svariati modelli di GPS facilmente utilizzabili nelle nostre applicazioni hobbvstiche, a prezzi sempre più ridotti. Per un acquisto consapevole ci sono alcuni parametri da tenere in considerazione: la dimensione, ad esempio, è un parametro importante soprattutto in apparecchiature che devono limitare gli ingombri; in questo rientra anche il discorso dell'antenna ricevente, che può essere integrata oppure esterna.

    Un altro parametro importante è il numero di letture che è in grado di fornire in un secondo: quasi tutti i modelli commerciali a basso costo forniscono una lettura al secondo, mentre i più evoluti arrivano anche a 10 lettine al secondo. L'alimentazione è un altro parametro di estrema importanza; di solito i ricevitori sono apparati progettati per funzionare in apparecchiature portatili e quindi pensati per esseie alimentati a 3,3 o 5 volt con una corrente assorbita, variabile a seconda del modello, tra 10 e 50 mA, valore che va riducendosi con il migliorare della tecnologia. Il numero dei canali gestibili è un altro parametro di solito sbandierato dai produttori, ma spesso una quantità inferiore di satelliti ben agganciati ed elaborati assicura migliori risultati di tanti satelliti ricevuti male.

    La sensibilità fornisce un'indicazione della capacità di poter agganciare anche segnali deboli e quindi è indice di un buon funzionamento anche in zone disturbate o in cui giunge un segnale, debole come in centro città.

    La precisione è un altro parametro di sicura importanza ed è strettamente legato al prezzo dell'apparato; tralasciando costose versioni per misure sul territorio (catasto o viabilità) i ricevitori commerciali si attestano su una precisione di ±10 metri o poco meno. Per chi di voi si stia chiedendo a cosa possano servire i ricevitori GPS, diciamo che la loro principale applicazione è la memorizzazione di un percorso, nel caso di escursionisti, o la tracciabilità dei veicoli; più raramente, i GPS si usano per la navigazione di veicoli senza pilota.

    Molto più spesso li troviamo integrati negli smartphone di ultima generazione, così da rendere disponibile una serie di servizi tra cui la visita guidata alle città d'arte o da aiutarci a recuperare la strada di casa durante una vacanza in una nuova città; gli smartphone con ricevitore GPS possono diventare (con appositi software) navigatori satellitari dotati di assistenza vocale. Tra i modelli disponibili sul mercato ne abbiamo selezionati un paio di facile reperibilità e pienamente compatibili con la nostra scheda Arduino; infatti, vista l'estrema miniaturizzazione di questi apparati, l'uso con una semplice breadboard e qualche spezzone di filo non risulta molto agevole. Il primo modello che prendiamo in considerazione si chiama EM406A ed è un modulo GPS a 20 canali con antenna integrata, le cui caratteristiche essenziali sono:

    • chipset GPS a 20 canali SiRFStar III;
    • alta sensibilità (-159 dBm);
    • precisione nella posizione di ±10 metri, 2D RMS e di ±5 metri, 2D RMS;
    • precisione nel calcolo della velocità di ±0,1 m/s;
    • TTFF (Time To First Fix) estremamente efficace anche con livello di segnale non ottimale;
    • supporta lo standard dati NMEA 0183 GGA, GSA, GSV, RMC, VTG e GLL;
    • protocollo di comunicazione in logica TTL a 4.800 bps;
    • tecnologia SuperCap che permette una rapida acquisizione dei dati dal satellite;
    • antenna patch integrata;
    • tempo di cold start di 42 s (da spento ad acceso);
    • tempo di hot start di 1 secondo;
    • alimentazione: 4,5 V ~ 6,5 V;
    • consumo: 44 mA;
    • dimensioni di 30x30x10,5 mm.

    E' possibile impostare il ricevitore per fornire diverse serie di dati in uscita; ad esempio, la sequenza GGA è quella illustrata nella Tabella 3. La stringa ricevuta, detta anche sentenza, è quindi la seguente:


    $GPGGA,161229.487,3723.2475,N,12158.3416,W,1,07,1.0,9.0,M,,,,0000*18

    Ma veniamo all'utilizzo pratico di questo ricevitore GPS (siglato EM-406A) reperibile presso la ditta Futura Elettronica (www.futurashop.it) con codice 8160-EM406A, completo di cavetto di collegamento. Per chi volesse utilizzarlo direttamente su di una breadboard per fare degli esperimenti, consigliamo di eliminare il connettore di uscita in dotazione e rimpiazzarlo con uno più adatto; se invece intendete realizzare da voi uno stampato per ricevere i segnali da questo modulo, potete trovare, sempre a catalogo Futura Elettronica, il relativo connettore (codice 7300-CONNEM406A).

    Per interfacciare correttamente questo modulo con la scheda Arduino, possiamo semplicemente utilizzare l'apposita GPS-Shield disponibile sempre dalla Futura Elettronica con il codice 7300-GPSSHIELD, fornita già montata ed equipaggiata con il connettore per il modulo EM406A; in essa sono presenti anche un pulsante di reset ed uno di ON/OFF per il modulo GPS. Non comprende, però, i connettori per il fissaggio alla scheda Arduino che dovrete acquistare a parte (7300-STRIP6 e 7300-STRIP8) e successivamente saldare.

    Questa scheda dispone inoltre di piazzole per il collegamento del modulo EM408, funzionante a 3,3 V. Per il modulo EM406, la scheda provvede a fornire l'alimentazione a 5 volt ed il cablaggio dei due segnali TX ed RX del GPS con le linee D2 e D3 di Arduino. Particolare attenzione deve essere posta nell'uso del deviatore DLINE-UART. Con il deviatore in posizione UART il modulo GPS è connesso alle linee digitali 0 e 1, ovvero le linee TX ed RX del modulo UART di Arduino. Con il deviatore in posizione DLINE il ricevitore GPS è connesso alle linee digitali D2 e D3 di Arduino.

    Ponete il deviatore nella posizione DLINE sia per programmare Arduino sia per testare gli sketch; in questo modo non ci sarà alcun conflitto con i dati provenienti dalla USB, che invece impegnano le linee TX ed RX (pin 0 e 1). Assicuratevi che il modulo EM406 non tocchi le piazzole sottostanti lo stampato della GPS-shield e in caso contrario isolatelo con della plastica. A questo punto potete occuparvi della programmazione, obiettivo della quale è leggere la stringa che esce ogni secondo dal modulo EM406, estrapolando le varie sentenze contenenti i dati.

    Aver utilizzato la piattaforma Arduino ci assicura la disponibilità in rete di un'apposita libreria che ci assolva dal compito di dover redigere un complicato software. Le librerie che andiamo ad utilizzare si chiamano NeoSoftSerial e TinyGPS, sono state CREATE da Mikal Hart e risultano reperibili all'indirizzo web http://arduiniana.org; entrambe le librerie, come al solito, andranno copiate nella directory libraries del software Arduino.

    In alternativa potete scaricare queste librerie all'indirizzo http://www.lungolagocapodimonte.it/component/jdownloads/viewcategory/8.html. Assicuratevi che il deviatore di alimentazione sulla GPS shield sia in posizione ON e che il secondo deviatore sia in posizione DLINK, poi collegate Arduino al PC con il solito cavo USB. Sulla GPS shield si deve accendere il LED rosso (alimentazione OK); il LED sul modulo EM406 darà le seguenti indicazioni:

    • LED OFF = ricevitore spento;
    • LED ON = non agganciato, ricerca del segnale;
    • LED lampeggiante = segnale agganciato.

    Listato 1

    {codecitation brush:cpp}

    // Queste righe servono ad includere le due librerie
    #include <NewSoftSerial.h>
    #include <TinyGPS.h>

    // Si definiscono i pin usati per la comunicazione con Arduino ed il baud rate del modulo GPS
    #define RXPIN 3
    #define TXPIN 2
    #define GPSBAUD 4800

    // Viene creata un'istanza all'oggetto TinyGPS
    TinyGPS gps;
    // Si inizializza la libreria NewSoftSerial utilizzata per la comunicazione con il modulo GPS
    NewSoftSerial uart_gps(RXPIN, TXPIN);

    // Si dichiara un prototipo per la funzione della libreria TinyGPS.
    void getgps(TinyGPS &gps);

    void setup()
    {
    // Si inizializza il modulo UART per la comunicazione con il PC.
    Serial.begin(115200);
    // Si imposta il baud rate per il modulo GPS
    uart_gps.begin(GPSBAUD);

    // Testo iniziale inviato dallo sketch verso il PC

    Serial.println("");
    Serial.println("GPS Shield QuickStart Example Sketch v12");
    Serial.println("       ...waiting for lock...           ");
    Serial.println("");
    }


    // Il loop principale semplicemente aspetta l'arrivo di una sentenza valida dal modulo GPS
    // quindi ne estrae le sotto stringhe richieste e le invia al PC

    void loop()
    {
    while(uart_gps.available())     // Aspetta l'arrivo di dati validi
    {
    int c = uart_gps.read();    // Carica i dati ricevuti nella variabile c
    if(gps.encode(c))      // Verifica congruenza dati
    {
    getgps(gps);         // Estrapola le sottostringhe di dati e le invia al PC
    }
    }
    }


    void getgps(TinyGPS &gps)
    {

    // Richiama la funzione che estrapola dalla sentenza i dati relativi alla posizione

    float latitude, longitude;
    gps.f_get_position(&latitude, &longitude);

    // Invia al PC i dati estrapolati
    Serial.print("Lat/Long: ");
    Serial.print(latitude,5);
    Serial.print(", ");
    Serial.println(longitude,5);

    // Richiama la funzione che estrapola dalla sentenza i dati relativi alla data

    int year;
    byte month, day, hour, minute, second, hundredths;
    gps.crack_datetime(&year,&month,&day,&hour,&minute,&second,&hundredths);

    // Invia al PC i dati estrapolati
    Serial.print("Date: "); Serial.print(month, DEC); Serial.print("/");
    Serial.print(day, DEC); Serial.print("/"); Serial.print(year);
    Serial.print("  Time: "); Serial.print(hour, DEC); Serial.print(":");
    Serial.print(minute, DEC); Serial.print(":"); Serial.print(second, DEC);
    Serial.print("."); Serial.println(hundredths, DEC);



    // Si può usare una sintassi diretta per inviare al PC i dati estratti

    Serial.print("Altitude (meters): "); Serial.println(gps.f_altitude());  
    Serial.print("Course (degrees): "); Serial.println(gps.f_course());
    Serial.print("Speed(kmph): "); Serial.println(gps.f_speed_kmph());
    Serial.println();

    // Here you can print statistics on the sentences.

    unsigned long chars;
    unsigned short sentences, failed_checksum;
    gps.stats(&chars, &sentences, &failed_checksum);
    //Serial.print("Failed Checksums: ");Serial.print(failed_checksum);
    //Serial.println(); Serial.println();
    }

    {/codecitation}

    Aprite l'ambiente Arduino, importate l'esempio TinyGPS->StaticTest e caricatelo sul microcontrollore di Arduino. Aprite Tools->Serial Monitor ed impostate la comunicazione su 115.200 Baud; riceverete una serie di dati preimpostati dal software, ma non ancora provenienti dal modulo GPS. Questa prima fase vi assicura che il trasferimento e la visualizzazione dei dati siano corretti. Scaricate quindi l'esempio denominato gps_parsing_v12ii.pde scritto da Aaron Weiss e reperibile cliccando QUI , poi caricatelo su Arduino; avviate Tool->SerialMonitor e finalmente a video vi ritroverete i dati acquisiti dal vostro GPS.

    Se il LED del modulo EM406A rimane a luce fissa per più di un minuto, significa che siete in una posizione nella quale il segnale GPS non giunge con la sufficiente intensità. Spostatevi all'esterno, in una zona facilmente raggiungibile dai segnali satellitari, ed attendete che il modulo agganci correttamente i satelliti e cominci la fase di tracking nella quale, ogni secondo, invia i dati relativi alla posizione. Vediamo ora in dettaglio come funziona questo sketch, che viene meglio descritto dal Listato 1.

    Si parte con due righe di codice che servono a includere le librerie NewSoftSerial.h e TinyGPS.h e, a seguire, vengono definiti i pin da utilizzare per acquisire i dati e il baud-rate corrispondente. Poi vengono CREATE le istanze e inizializzate le librerie, quindi si inizializza l'UART e lo si imposta a 115.200 band; ora parte il loop principale nel quale lo sketch attende l'arrivo di stringhe di dati dal lettore GPS. Quando questi arrivano, le elabora per estrapolare latitudine e longitudine (oltre ad altri dati significativi) e ne invia le informazioni al PC. L'elenco completo dei dati estraibili dalla sentenza GGA in arrivo dal ricevitore GPS sono i seguenti:

    -  get_position;
    -  get_datetime;
    -  altitude;
    -  speed;
    -  course;
    -  stats;
    -  f_get_position;
    -  crack_datetime;
    -  f_altitude;
    -  f_course;
    -  f_speed_knots;
    -  f_speed_mph;
    -  f_speed_mps;
    -   f_speed_kmph;
    -  library_version;

    Un primo semplice utilizzo dei dati acquisiti si può fare inserendo direttamente su Google Maps® le coordinate relative alla posizione, in modo da rintracciare il ricevitore sulle mappe di Google. Dalla riga in cui sono specificate la latitudine e la longitudine (Lat/Long:) estrapolate i due numeri successivi ed inseriteli nel seguente indirizzo internet: http://maps.google.com; per l'esattezza, componete nella casella degli indirizzi del browser una stringa del tipo http://maps.google.com/maps?q=45.643876,8.814163, dove al posto di 45.643876, 8.814163 dovete scrivere le due coordinate desunte dalla vostra applicazione.

    Inserendo la stringa e premendo Invio (o facendo clic sul pulsante di inoltro dell'indirizzo) si aprirà la pagina web di Google Maps® con la posizione specificata sulla cartina sia in modalità stradale che satellitare, a scelta. Per sperimentare applicazioni GPS con Arduino, potete usare un secondo modulo GPS denominato GTS Bee, facente uso del chipset U-BLOX5 e capace di ricevere sino a 50 satelliti contemporaneamente (ha quindi 50 canali); il suo formato lo rende del lutto compatibile con l'hardware dei moduli XBee. Le caratteristiche di questo modulo sono le seguenti:

    • chipset U-BLOX 5;
    • hot Start in 1 secondo;

    • sensibilità di -160 dBm in acquisizione e cracking;
    • precisione nella posizione di ±2 metri;
    • precisione nel calcolo della velocità di ±0,1 m/s;
    • avvio accelerato a segnali deboli per moduli con funzione Kickstart;
    • supporto servizi AssistNow Online e Assist Now Offline A-GPS; compatibile OMA SUPL;
    • elevata immunità ai disturbi;
    • frequenza di aggiornamento della posizione 4 Hz;
    • interfacce UART, USB, DDC e SPI;
    • alimentazione: 2,7 V ~ 3,6 V;
    • assorbimento: 44 mA;
    • dimensioni XBee compatibili.

    Questo modulo necessita di antenna esterna, come ad esempio la MINI ANTENNA GPS 15x15 mm con CONNETTORE U.FL, disponibile presso la ditta Futura Elettronica (codice Cod. 8160-MINIANTGPS) le cui caratteristiche sono:

    • alimentazione: 3,3 V ~ 5 mA;
    • V.S.W.R. (Rapporto Onde Stazionarie): <2;
    • guadagno:20 dB;
    • peso: 15 g;
    • dimensioni: 15 x 15 x 6,4 mm;
    • lunghezza cavo: 90 mm.

    Questo modulo GPS-Bee è facilmente interfacciabile con il PC utilizzando l'apposito adattatore XBee-USB (codice 7300-UARTSBV31 della Futura Elettronica). Grazie al software U-Center, scaricabile gratuitamente all'indirizzo http://www.lungolagocapodimonte.it/component/jdownloads/viewcategory/9.html ( U-Center Installer 5.07 ) , è possibile visualizzare a video tutti i dati relativi a tempo, velocità, latitudine e longitudine, ecc.

    Lo shield Arduino XBee consente di interfacciare velocemente il modulo alla scheda Arduino, realizzando in maniera fissa le connessioni delle linee TX ed RX del modulo, alle linee TX ed RX della scheda Arduino, le quali, sono anche utilizzate dal convertitore USB-Seriale per l'interfacciamento alla porta USB. Questo vincolo non consente di gestire in contemporanea la comunicazione da parte del microcontrollore sia con il modulo GPS che con la porta USB; per i particolari, si veda la sesta puntata del corso, relativa ai moduli XBee.

    Per la lettura dei dati in arrivo dal modulo GPS è possibile usare la libreria standard "Seriale" impostata per un Baud-Rate di 9.600 Baud, mentre la decodifica della sentenza può avvenire con la libreria precedentemente descritta.

     

    Alcune foto

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     


    Aggiungi commento


    Codice di sicurezza
    Aggiorna