Voir la source de GPS LEA-5H shield Arduino

La shield GPS pour ARDUINO basée sur le module [http://www.u-blox.com/en/lea-5h.html LEA_5H] de U-BLOX permet une location fiable en extérieure. Couplé à une antenne GPS, le LEA-5H permet de recevoir les signaux satellites GPS et GALILEO.

Cette [http://www.dfrobot.com/wiki/index.php?title=DFRduino_GPS_Shield-LEA-5H_%28SKU:TEL0044%29 shield], proposée par DFRobot , permet une utilisation simple du module en intégrant les composants nécessaire à son utilisation (régulation de tension, résistances de pull-up pour la liaison i2c, led de power et fonctionnement, connecteur USB et antenne...).

== Communication ==
Le module LEA-5H intègre plusieurs mode de communication : USB, série, i2c.

Il suit la norme [http://fr.wikipedia.org/wiki/NMEA_0183 NMEA 0183] et envoie plusieurs trames GPS : RMC, VTG, GGA, GSA, GSV, GLL.
GGA est la plus courante, elle donne la position (latitude, longitude et altitude) du récepteur. Le détail des trames est expliquées [http://www.u-blox.com/images/downloads/Product_Docs/u-blox5_Protocol_Specifications%28GPS.G5-X-07036%29.pdf ici].

Toutes les trames sont envoyées à chaque demande sous forme de caractères ASCII. Le code de la trame est envoyée en tête en commençant par $ (par exemple, $GPGGA) puis chaque valeur séparée par une virgule (4825.2680,N,00110.3895,E). Si la valeur n'est pas disponible (perte de communication avec le satellite) elle n'est pas envoyée, seules les virgules permettent de connaître le paramètre ($GPGGA,,,,,,,,,).
.

=== USB ===
La shield peut être branchée à un ordinateur (port USB). Les données GPS sont directement transmises et peuvent être lues grâce à un terminal série (9600 bauds, 8 bits, 1 bit stop, sans parité). Les trames RMC, VTG, GGA, GSA, GSV et GLL sont envoyées environ toutes les secondes.

=== I2C ===
La liaison i2c se fait grâce à une ARDUINO.

==== Exemple Langage ARDUINO ====

Un exemple est expliqué [http://www.dfrobot.com/wiki/index.php?title=DFRduino_GPS_Shield-LEA-5H_%28SKU:TEL0044%29 ici].

==== Exemple Langage C ====

La liaison twi (i2c) et les fonctions sont expliquées [http://geonobotwiki.free.fr/doku.php?id=robotics:computing:communication_twi_entre_atmega ici]

Pour notre exemple, nous utilisons une carte ARDUINO UNO configurée en maitre. Le module GPS est utilisé en esclave à l'adresse 0x42.
Les trames GPS sont stockées à l'adresse 0xFF. Nous utiliserons la trame GGA pour afficher la position ( latitude, longitude et l'altitude) du récepteur GPS.

Nous avons créé une structure gps qui contient la latitude, longitude et l'altitude. Les données sont stockées sous forme de chaînes de caractères ASCII. Par exemple, pour une latitude de 48°45'2584, la chaine latitude contiendra le code ASCII de chaque valeur : 52 (pour 4), 56 (pour 8)...

Comme tous les formats de trames sont envoyés, il faut retrouver la trame GGA et identifier les paramètres qui nous intéresse. Pour commencer, on demande une lecture de 200 octets. Une fois reçus, la fonction gps_gpgga() parcourt le buffer pour retrouver la séquence $GPGGA. Quand l'entête a été retrouvée, il suffit de compter les virgules pour connaître le paramètre.
La fonction gps_print() permet d'envoyer les paramètres sur le port série pour les afficher dans un terminal.

<syntaxhighlight lang="c">
typedef struct
{
  uint8_t latitude[9];
  uint8_t dir_lat;
  uint8_t longitude[11];
  uint8_t dir_long;
  uint8_t altitude[5];
} gps;

/* GPS GGA message */
gps
gps_gpgga(uint8_t *buffer)
{
  gps g;
  uint8_t gpgga[6] =
    { '$', 'G', 'P', 'G', 'G', 'A' };

  uint8_t header = 0;
  uint8_t j = 0, count = 0;

  for (uint8_t i = 0; i < 200; i++)
    {
      if (!header)
        {
          if (buffer[i] == gpgga[j])
            {
              j++;
              if (j == 6)
                {
                  header = 1;
                }
            }
        }
      else
        {
          if (buffer[i] == ',')
            {
              count++;
              j = 0;
            }
          else
            {
              switch (count)
                {
              case 1: // utc time
                break;
              case 2: // latitude
                g.latitude[j] = buffer[i];
                break;
              case 3: // direction latitude
                g.dir_lat = buffer[i];
                break;
              case 4: // longitude
                g.longitude[j] = buffer[i];
                break;
              case 5: // direction longitude
                g.dir_long = buffer[i];
                break;
              case 9: // altitude
                g.altitude[j] = buffer[i];
                break;
              case 10: //
              default:
                break;
                }
              j++;
            }
        }
    }
  return g;
}

void
gps_print(gps g)
{
  uint8_t lat[11] =
    { "latitude : " };
  uint8_t lon[12] =
    { "longitude : " };
  uint8_t alt[11] =
    { "altitude : " };

  for (uint8_t i = 0; i < 11; i++)
    {
      usart_0_transmit(lat[i]);
    }
  for (uint8_t i = 0; i < 9; i++)
    {
      usart_0_transmit(g.latitude[i]);
    }
  usart_0_transmit(' ');
  usart_0_transmit(g.dir_lat);
  usart_0_transmit('\n');

  for (uint8_t i = 0; i < 12; i++)
    {
      usart_0_transmit(lon[i]);
    }
  for (uint8_t i = 0; i < 11; i++)
    {
      usart_0_transmit(g.longitude[i]);
    }
  usart_0_transmit(' ');
  usart_0_transmit(g.dir_long);
  usart_0_transmit('\n');

  for (uint8_t i = 0; i < 11; i++)
    {
      usart_0_transmit(alt[i]);
    }
  for (uint8_t i = 0; i < 5; i++)
    {
      usart_0_transmit(g.altitude[i]);
    }
  usart_0_transmit(' ');
  usart_0_transmit('m');
  usart_0_transmit('\n');
}

void
setup(void)
{
  twi_master_setup();
  usart_0_setup();
  usart_0_transmitter_enable();
}

int
main(void)
{
  gps g;
  setup();
  while (1)
    {
      uint8_t reg = 0xFF;
      uint8_t buffer[200];
      twi_read_bytes((0x42 << 1), &reg, 200, buffer);

      g = gps_gpgga(buffer);

      gps_print(g);
      _delay_ms(2000);
    }
  return 1;
}
</syntaxhighlight>

[[Category:Produits]]