GPS Challenge

/ / Assignment

The city is a dirty a place, but that's no reason not to have an easter egg hunt. You will design and program a device that will do three things:

Allow you to set locations (where your virtual easter eggs will be hidden)
Once the hiding places have been set, your device will help a seeker, through a series of clues, find the hiding spots.
When a hiding spot has been discovered, a treat will be dispensed

GPS modules typically put out a series of standard strings of information, under something called the National Marine Electronics Association (NMEA) protocol. More information on NMEA standard data strings can be found at this site

The tutorial code at the bottom of this page demonstrates how to decode and display the most common string, called $GPRMC. If all you need is date, time and position, you can to skip reading this, and just run the code below.

While you can write software to serially request other strings from the Parallax module, the following strings are automatically transmitted when the "/RAW" pin is pulled low.

$GPGGA: Global Positioning System Fix Data
$GPGSV: GPS satellites in view
$GPGSA: GPS DOP and active satellites
$GPRMC: Recommended minimum specific GPS/Transit data

Each of these sentences contains a wealth of data. For example, here are a few instances of the $GPRMC string, aka the "Recommended minimum specific GPS/Transit data" string:

 eg1. $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
 eg2. $GPRMC,225446,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68

           225446       Time of fix 22:54:46 UTC
           A            Navigation receiver warning A = Valid position, V = Warning
           4916.45,N    Latitude 49 deg. 16.45 min. North
           12311.12,W   Longitude 123 deg. 11.12 min. West
           000.5        Speed over ground, Knots
           054.7        Course Made Good, degrees true
           191194       UTC Date of fix, 19 November 1994
           020.3,E      Magnetic variation, 20.3 deg. East
           *68          mandatory checksum
           
eg3. $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70
              1    2    3    4    5     6    7    8      9     10  11 12

      1   220516     Time Stamp
      2   A          validity - A-ok, V-invalid
      3   5133.82    current Latitude
      4   N          North/South
      5   00042.24   current Longitude
      6   W          East/West
      7   173.8      Speed in knots
      8   231.8      True course
      9   130694     Date Stamp
      10  004.2      Variation
      11  W          East/West
      12  *70        checksum

 eg4. for NMEA 0183 version 3.00 active the Mode indicator field is added
     $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a,m*hh
 Field #
 1    = UTC time of fix
 2    = Data status (A=Valid position, V=navigation receiver warning)
 3    = Latitude of fix
 4    = N or S of longitude
 5    = Longitude of fix
 6    = E or W of longitude
 7    = Speed over ground in knots
 8    = Track made good in degrees True
 9    = UTC date of fix
 10   = Magnetic variation degrees (Easterly var. subtracts from true course)
 11   = E or W of magnetic variation
 12   = Mode indicator, (A=Autonomous, D=Differential, E=Estimated, N=Data not valid)
 13   = Checksum

Parsing the data

Move TX to pin 2 and RX to pin 3, POWER to pin 4.

Upload this code:

// A simple sketch to read GPS data and parse the $GPRMC string 
// see http://www.ladyada.net/make/gpsshield for more info

#include <NewSoftSerial.h>

NewSoftSerial mySerial =  NewSoftSerial(2, 3);
#define powerpin 4

#define GPSRATE 4800
//#define GPSRATE 38400


// GPS parser for 406a
#define BUFFSIZ 90 // plenty big
char buffer[BUFFSIZ];
char *parseptr;
char buffidx;
uint8_t hour, minute, second, year, month, date;
uint32_t latitude, longitude;
uint8_t groundspeed, trackangle;
char latdir, longdir;
char status;

void setup() 
{ 
  if (powerpin) {
    pinMode(powerpin, OUTPUT);
  }
  pinMode(13, OUTPUT);
  Serial.begin(GPSRATE);
  mySerial.begin(GPSRATE);
   
  // prints title with ending line break 
  Serial.println("GPS parser"); 
 
   digitalWrite(powerpin, LOW);         // pull low to turn on!
} 
 
 
void loop() 
{ 
  uint32_t tmp;
  
  Serial.print("\n\rread: ");
  readline();
  
  // check if $GPRMC (global positioning fixed data)
  if (strncmp(buffer, "$GPRMC",6) == 0) {
    
    // hhmmss time data
    parseptr = buffer+7;
    tmp = parsedecimal(parseptr); 
    hour = tmp / 10000;
    minute = (tmp / 100) % 100;
    second = tmp % 100;
    
    parseptr = strchr(parseptr, ',') + 1;
    status = parseptr[0];
    parseptr += 2;
    
    // grab latitude & long data
    // latitude
    latitude = parsedecimal(parseptr);
    if (latitude != 0) {
      latitude *= 10000;
      parseptr = strchr(parseptr, '.')+1;
      latitude += parsedecimal(parseptr);
    }
    parseptr = strchr(parseptr, ',') + 1;
    // read latitude N/S data
    if (parseptr[0] != ',') {
      latdir = parseptr[0];
    }
    
    //Serial.println(latdir);
    
    // longitude
    parseptr = strchr(parseptr, ',')+1;
    longitude = parsedecimal(parseptr);
    if (longitude != 0) {
      longitude *= 10000;
      parseptr = strchr(parseptr, '.')+1;
      longitude += parsedecimal(parseptr);
    }
    parseptr = strchr(parseptr, ',')+1;
    // read longitude E/W data
    if (parseptr[0] != ',') {
      longdir = parseptr[0];
    }
    

    // groundspeed
    parseptr = strchr(parseptr, ',')+1;
    groundspeed = parsedecimal(parseptr);

    // track angle
    parseptr = strchr(parseptr, ',')+1;
    trackangle = parsedecimal(parseptr);


    // date
    parseptr = strchr(parseptr, ',')+1;
    tmp = parsedecimal(parseptr); 
    date = tmp / 10000;
    month = (tmp / 100) % 100;
    year = tmp % 100;
    
    Serial.print("\nTime: ");
    Serial.print(hour, DEC); Serial.print(':');
    Serial.print(minute, DEC); Serial.print(':');
    Serial.println(second, DEC);
    Serial.print("Date: ");
    Serial.print(month, DEC); Serial.print('/');
    Serial.print(date, DEC); Serial.print('/');
    Serial.println(year, DEC);
    
    Serial.print("Lat: "); 
    if (latdir == 'N')
       Serial.print('+');
    else if (latdir == 'S')
       Serial.print('-');

    Serial.print(latitude/1000000, DEC); Serial.print('\°', BYTE); Serial.print(' ');
    Serial.print((latitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
    Serial.print((latitude%10000)*6/1000, DEC); Serial.print('.');
    Serial.print(((latitude%10000)*6/10)%100, DEC); Serial.println('"');
   
    Serial.print("Long: ");
    if (longdir == 'E')
       Serial.print('+');
    else if (longdir == 'W')
       Serial.print('-');
    Serial.print(longitude/1000000, DEC); Serial.print('\°', BYTE); Serial.print(' ');
    Serial.print((longitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
    Serial.print((longitude%10000)*6/1000, DEC); Serial.print('.');
    Serial.print(((longitude%10000)*6/10)%100, DEC); Serial.println('"');
   
  }
  //Serial.println(buffer);
}

uint32_t parsedecimal(char *str) {
  uint32_t d = 0;
  
  while (str[0] != 0) {
   if ((str[0] > '9') || (str[0] < '0'))
     return d;
   d *= 10;
   d += str[0] - '0';
   str++;
  }
  return d;
}

void readline(void) {
  char c;
  
  buffidx = 0; // start at begninning
  while (1) {
      c=mySerial.read();
      if (c == -1)
        continue;
      Serial.print(c);
      if (c == '\n')
        continue;
      if ((buffidx == BUFFSIZ-1) || (c == '\r')) {
        buffer[buffidx] = 0;
        return;
      }
      buffer[buffidx++]= c;
  }
}

This next example uses TinyGPS and only acquires data if you have a valid fix:

#include <NewSoftSerial.h>
#include <TinyGPS.h>

/* This sample code demonstrates the normal use of a TinyGPS object.
   It requires the use of NewSoftSerial, and assumes that you have a
   4800-baud serial GPS device hooked up on pins 2(rx) and 3(tx).
*/

TinyGPS gps;
NewSoftSerial nss(2, 3);
#define powerpin 4

void gpsdump(TinyGPS &gps);
bool feedgps();
void printFloat(double f, int digits = 2);

void setup()
{
  if (powerpin) {
    pinMode(powerpin, OUTPUT);
  }
  Serial.begin(115200);
  nss.begin(4800);
  
  Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
  Serial.println("by Mikal Hart");
  Serial.println();
  Serial.print("Sizeof(gpsobject) = "); Serial.println(sizeof(TinyGPS));
  Serial.println();
}

void loop()
{
  bool newdata = false;
  unsigned long start = millis();

  // Every 5 seconds we print an update
  while (millis() - start < 5000)
  {
    if (feedgps())
      newdata = true;
  }
  
  if (newdata)
  {
    Serial.println("Acquired Data");
    Serial.println("-------------");
    gpsdump(gps);
    Serial.println("-------------");
    Serial.println();
  }
}

void printFloat(double number, int digits)
{
  // Handle negative numbers
  if (number < 0.0)
  {
     Serial.print('-');
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
    rounding /= 10.0;
  
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
  Serial.print(int_part);

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0)
    Serial.print("."); 

  // Extract digits from the remainder one at a time
  while (digits-- > 0)
  {
    remainder *= 10.0;
    int toPrint = int(remainder);
    Serial.print(toPrint);
    remainder -= toPrint; 
  } 
}

void gpsdump(TinyGPS &gps)
{
  long lat, lon;
  float flat, flon;
  unsigned long age, date, time, chars;
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned short sentences, failed;

  gps.get_position(&lat, &lon, &age);
  Serial.print("Lat/Long(10^-5 deg): "); Serial.print(lat); Serial.print(", "); Serial.print(lon); 
  Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms.");
  
  feedgps(); // If we don't feed the gps during this long routine, we may drop characters and get checksum errors

  gps.f_get_position(&flat, &flon, &age);
  Serial.print("Lat/Long(float): "); printFloat(flat, 5); Serial.print(", "); printFloat(flon, 5);
  Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms.");

  feedgps();

  gps.get_datetime(&date, &time, &age);
  Serial.print("Date(ddmmyy): "); Serial.print(date); Serial.print(" Time(hhmmsscc): "); Serial.print(time);
  Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms.");

  feedgps();

  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  Serial.print("Date: "); Serial.print(static_cast<int>(month)); Serial.print("/"); Serial.print(static_cast<int>(day)); Serial.print("/"); Serial.print(year);
  Serial.print("  Time: "); Serial.print(static_cast<int>(hour)); Serial.print(":"); Serial.print(static_cast<int>(minute)); Serial.print(":"); Serial.print(static_cast<int>(second)); Serial.print("."); Serial.print(static_cast<int>(hundredths));
  Serial.print("  Fix age: ");  Serial.print(age); Serial.println("ms.");
  
  feedgps();

  Serial.print("Alt(cm): "); Serial.print(gps.altitude()); Serial.print(" Course(10^-2 deg): "); Serial.print(gps.course()); Serial.print(" Speed(10^-2 knots): "); Serial.println(gps.speed());
  Serial.print("Alt(float): "); printFloat(gps.f_altitude()); Serial.print(" Course(float): "); printFloat(gps.f_course()); Serial.println();
  Serial.print("Speed(knots): "); printFloat(gps.f_speed_knots()); Serial.print(" (mph): ");  printFloat(gps.f_speed_mph());
  Serial.print(" (mps): "); printFloat(gps.f_speed_mps()); Serial.print(" (kmph): "); printFloat(gps.f_speed_kmph()); Serial.println();

  feedgps();

  gps.stats(&chars, &sentences, &failed);
  Serial.print("Stats: characters: "); Serial.print(chars); Serial.print(" sentences: "); Serial.print(sentences); Serial.print(" failed checksum: "); Serial.println(failed);
}
  
bool feedgps(){
  while (nss.available()){
    if (gps.encode(nss.read()))
      return true;
  }
  return false;
}

This next sketch just prints out the lat and long in a format google earth and google maps can use:

#include <NewSoftSerial.h>
#include <TinyGPS.h>

/* This sample code demonstrates the normal use of a TinyGPS object.
   It requires the use of NewSoftSerial, and assumes that you have a
   4800-baud serial GPS device hooked up on pins 2(rx) and 3(tx).
*/

TinyGPS gps;
NewSoftSerial nss(2, 3);
#define powerpin 4

void gpsdump(TinyGPS &gps);
bool feedgps();
void printFloat(double f, int digits = 2);

void setup()
{
  if (powerpin) {
    pinMode(powerpin, OUTPUT);
  }
  Serial.begin(115200);
  nss.begin(4800);
  
  Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
  Serial.println("by Mikal Hart");
  Serial.println();
  Serial.print("Sizeof(gpsobject) = "); Serial.println(sizeof(TinyGPS));
  Serial.println();
}

void loop()
{
  bool newdata = false;
  unsigned long start = millis();

  // Every 5 seconds we print an update
  while (millis() - start < 5000)
  {
    if (feedgps())
      newdata = true;
  }
  
  if (newdata)
  {
    Serial.println("Acquired Data");
    Serial.println("-------------");
    gpsdump(gps);
    Serial.println("-------------");
    Serial.println();
  }
}

void printFloat(double number, int digits)
{
  // Handle negative numbers
  if (number < 0.0)
  {
     Serial.print('-');
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
    rounding /= 10.0;
  
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
  Serial.print(int_part);

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0)
    Serial.print("."); 

  // Extract digits from the remainder one at a time
  while (digits-- > 0){
    remainder *= 10.0;
    int toPrint = int(remainder);
    Serial.print(toPrint);
    remainder -= toPrint; 
  } 
}

void gpsdump(TinyGPS &gps)
{
  long lat, lon;
  float flat, flon;

  feedgps(); // If we don't feed the gps during this long routine, we may drop characters and get checksum errors

  gps.f_get_position(&flat, &flon);
  Serial.print("Lat/Long(float): "); 
  printFloat(flat, 5);
  Serial.print(", ");
  printFloat(flon, 5);
   Serial.println(" ");
}
  
bool feedgps()
{
  while (nss.available())
  {
    if (gps.encode(nss.read()))
      return true;
  }
  return false;
}

Here is the same code with static data

#include <TinyGPS.h>
#include <avr/pgmspace.h>


/* This sample code demonstrates the basic use of a TinyGPS object.
   Typically, you would feed it characters from a serial GPS device, but 
   this example uses static strings for simplicity.
*/

prog_char str1[] PROGMEM = "$GPRMC,201547.000,A,3014.5527,N,09749.5808,W,0.24,163.05,040109,,*1A";
prog_char str2[] PROGMEM = "$GPGGA,201548.000,3014.5529,N,09749.5808,W,1,07,1.5,225.6,M,-22.5,M,18.8,0000*78";
prog_char str3[] PROGMEM = "$GPRMC,201548.000,A,3014.5529,N,09749.5808,W,0.17,53.25,040109,,*2B";
prog_char str4[] PROGMEM = "$GPGGA,201549.000,3014.5533,N,09749.5812,W,1,07,1.5,223.5,M,-22.5,M,18.8,0000*7C";
prog_char *teststrs[4] = {str1, str2, str3, str4};

void sendstring(TinyGPS &gps, const PROGMEM char *str);
void gpsdump(TinyGPS &gps);

void setup()
{
  Serial.begin(115200);
  
  Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
  Serial.println("by Mikal Hart");
  Serial.println();
  Serial.print("Sizeof(gpsobject) = "); Serial.println(sizeof(TinyGPS));
  Serial.println();

  for (int i=0; i<4; ++i)
  {
    TinyGPS test_gps;
    Serial.print("Test string #"); Serial.println(i+1);
    Serial.println("--------------");
    sendstring(test_gps, teststrs[i]);
    gpsdump(test_gps);
    Serial.println();
  }
}

void loop()
{
}

void printFloat(double number, int digits=5){
  // Handle negative numbers
  if (number < 0.0)
  {
     Serial.print('-');
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
    rounding /= 10.0;
  
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
  Serial.print(int_part);

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0)
    Serial.print("."); 

  // Extract digits from the remainder one at a time
  while (digits-- > 0)
  {
    remainder *= 10.0;
    int toPrint = int(remainder);
    Serial.print(toPrint);
    remainder -= toPrint; 
  } 
}

void sendstring(TinyGPS &gps, const PROGMEM char *str){
  while (true)
  {
    char c = pgm_read_byte_near(str++);
    if (!c) break;
    Serial.print(c);
    gps.encode(c);
  }
  Serial.println();
  gps.encode('\r');
  gps.encode('\n');
}

void gpsdump(TinyGPS &gps){
 float flat, flon;

   gps.f_get_position(&flat, &flon);
  Serial.print("Lat/Long(float): ");

  printFloat(flat); 
  Serial.print(", ");
  printFloat(flon);
 
}

Here is code to log data to the SD card. TX goes to pin 0, RX to 1, POWER to 2, led1Pin to 4 and led2Pin to 3

#include "AF_SDLog.h"
#include "util.h"
#include <avr/pgmspace.h>
#include <avr/sleep.h>

// Pins used for LED indicators for debugging.
#define led1Pin    4
#define led2Pin    3

// Pin used for GPS power control.
#define powerPin  2

// We want to use the RMC (basic location data) with WAAS augmentation,
// but we don't care about any other information from the GPS.
#define RMC_ON   "$PSRF103,4,0,1,1*21\r\n"  // the command we send to turn RMC on
#define WAAS_ON  "$PSRF151,1*3F\r\n"        // the command we send to turn WAAS on
#define GGA_OFF  "$PSRF103,0,0,0,1*24\r\n"  // the command we send to turn GGA off
#define GSA_OFF  "$PSRF103,2,0,0,1*26\r\n"  // the command we send to turn GSA off
#define GSV_OFF  "$PSRF103,3,0,0,1*27\r\n"  // the command we send to turn GSV off

// Size of buffer for reading GPS data line-by-line.
#define BUFFSIZE  75

// The buffer, a character array.
char buffer[BUFFSIZE];

// Where we are in the buffer (i.e., how many characters have been read so far.
uint8_t bufferidx = 0;

// An object that allows us to write to the SD card.
AF_SDLog card;

// The file that we will create on the SD card.
File f;





// Read a Hex value and return the decimal equivalent.
uint8_t parseHex(char c) {
  if (c < '0') return 0;
  if (c <= '9') return c - '0';
  if (c < 'A') return 0;
  if (c <= 'F') return (c - 'A')+10;
  
  // What if none of the above was true???
}

// Blink out an error code.
void error(uint8_t errno) {
  uint8_t i;
  while(1) {
    for (i=0; i<errno; i++) {
      digitalWrite(led1Pin, HIGH);
      digitalWrite(led2Pin, HIGH);
      delay(100);
      digitalWrite(led1Pin, LOW);
      digitalWrite(led2Pin, LOW);
      delay(100);
    }
    for (; i<10; i++) {
      delay(200);
    }
  }
}

void setupSerialPort() {
  // For efficiency, the serial port is shared between the USB (used for
  // debugging) and the GPS (used for getting location information).
  Serial.begin(4800);
  
  // Print "hello, world!" to the serial port to show that we are alive.
  putstring_nl("GPSlogger");
}

void setupGPS() {
  
  // Turn on the GPS by writing LOW to the powerPin.
  pinMode(powerPin, OUTPUT);
  digitalWrite(powerPin, LOW);
  
  // Turn on WAAS.
  putstring(WAAS_ON);
  
  // Turn on RMC (basic location data).
  putstring(RMC_ON);
  
  // Turn off everything else that might be on by default.
  putstring(GSV_OFF);
  putstring(GSA_OFF);
  putstring(GGA_OFF);
  
}

// This function uses the global variables "buffer[]" and "card".
void setupSDCard() {
  // If any of the following fails, we call "error()" which
  // is an endless loop that indicates the error using LEDs.
  
  // Try to initialize the card.
  if (!card.init_card()) {
    putstring_nl("Card init. failed!");
    error(1);
  }
  
  // Try to open a partition on the card.
  if (!card.open_partition()) {
    putstring_nl("No partition!");
    error(2);
  }
  
  // Try to open a file system on the card.
  if (!card.open_filesys()) {
    putstring_nl("Can't open filesys");
    error(3);
  }
  
  // Try to open the base directory on the card.
  if (!card.open_dir("/")) {
    putstring_nl("Can't open /");
    error(4);
  }
  
  // Try to find a good name for the logging file. Do this by
  // iterating through the numbers in the base name GPSLOG**.TXT.
  // Stop when we find the name of a file that does not yet exist.
  strcpy(buffer, "GPSLOG00.TXT");
  for (buffer[6] = '0'; buffer[6] <= '9'; buffer[6]++) {
    for (buffer[7] = '0'; buffer[7] <= '9'; buffer[7]++) {
      f = card.open_file(buffer);
      if (!f) {
        // We found a good name.
        break;
      }
      card.close_file(f);
    }
    if (!f) {
      // We found a good name. This is obviously a duplicate check.
      // This double-loop could have been implemented in a better way.
      break;
    }
  }
  
  // Try to create a file with the good name that we found.
  if(!card.create_file(buffer)) {
    putstring("couldnt create "); 
    Serial.println(buffer);
    error(5);
  }
  
  // Try to open the file that we just created for writing.
  f = card.open_file(buffer);
  if (!f) {
    putstring("error opening "); 
    Serial.println(buffer);
    card.close_file(f);
    error(6);
  }
  
  // Write a debug message saying that we're ready to write.
  putstring("writing to "); 
  Serial.println(buffer);
  putstring_nl("ready!");
  
}

// Updates the global variables buffer[] and bufferidx.
boolean gpsGetCharacter() {
  char c;
  
  // Check if any data is available to be read over the serial port.
  if (Serial.available()) {
    // Get the first available character.
    c = Serial.read();
    
    // If we aren't already in the middle of receiving a line of GPS data,
    // keep reading characters until we get one that indicates the start of
    // a line of GPS data.
    if (bufferidx == 0) {
      while (c != '$') {
        c = Serial.read();
      }
    }
    
    // Add the first character to the buffer.
    buffer[bufferidx] = c;
    
    // Check if we're at the end of a line of GPS data.
    if (c == '\n') {
      // Add a terminal character symbol to the end of the buffer.
      buffer[bufferidx+1] = 0;
      return true;
    } else {
      // Not at the end of a line yet, so increment bufferidx, which
      // says how many characters are currently in the buffer.
      bufferidx++;
      
      // Check if we are going to overflow the buffer. If so, print debugging
      // information over the serial port and discard the line.
      if (bufferidx == BUFFSIZE-1) {
        Serial.print('!', BYTE);
        bufferidx = 0;
      }
      
      return false;
    }
  } else {
    // No data available.
    return false;
  }
}

// Updates the global variables buffer[] and bufferidx.
boolean gpsChecksumIsOK() {
  uint8_t sum;
  uint8_t i;
  
  // Make sure there is a checksum. If there isn't, set the bufferidx
  // back to zero and return false, effectively ignoring the line of
  // GPS data we just finished reading.
  if (buffer[bufferidx-4] != '*') {
    Serial.print('*', BYTE);
    bufferidx = 0;
    return false;
  }
  
  // Get the checksum.
  sum = parseHex(buffer[bufferidx-3]) * 16;
  sum += parseHex(buffer[bufferidx-2]);
  
  // Verify the checksum. Again, ignore the line and return if it doesn't
  // match the data.
  for (i=1; i < (bufferidx-4); i++) {
    sum ^= buffer[i];
  }
  if (sum == 0) {
    return true;
  } else {
    Serial.print('~', BYTE);
    bufferidx = 0;
    return false;
  }
}

// Updates the global variables buffer[] and bufferidx.
boolean gpsGotRMCData() {
  // Verify that we got RMC (basic location) data, and that the GPS
  // device actually has a good "fix" on its location. If not, ignore
  // the line of data and return.
  if (strstr(buffer, "GPRMC")) {
    // Create a pointer to access a specific part of the buffer.
    char *p = buffer;
    // Skip to the second item (after the first comma).
    p = strchr(p, ',')+1;
    // Skip to the third item (after the second comma).
    p = strchr(p, ',')+1;
    
    // If the third item begins with the character 'V', then we have no fix.
    if (p[0] == 'V') {
      // Indicate we don't have a fix using LED1 and using the serial port.
      digitalWrite(led1Pin, LOW);
      Serial.print('_', BYTE);
      bufferidx = 0;
      return false;
    } else {
      // Indicate over the serial port and with LED1 that we are finally sure
      // that we have collected good data.
      Serial.print('#', BYTE);
      digitalWrite(led1Pin, HIGH);
      return true;
    }
  } else {
    return false;
  }
  
}

// Updates the global variables buffer[] and bufferidx.
// Also uses the global variables "card" and "f".
void sdWriteGPSData() {
  // Indicate with LED2 that we are trying to write.
  digitalWrite(led2Pin, HIGH);
  
  // Try to log the data. In doing this, we check to make sure that
  // we have written the number of characters that we expected to write.
  // If this does not occur, we display an error message over the serial port.
  if(card.write_file(f, (uint8_t *) buffer, bufferidx) != bufferidx) {
    putstring_nl("can't write!");
  }
  
  // Indicate with LED2 that we are done trying to write.
  digitalWrite(led2Pin, LOW);
  
  // Put us back at the beginning of a line.
  bufferidx = 0;
}







void setup()
{
  setupSerialPort();
  
  // Sets two digital pins as output; these are connected to LEDs
  // that we will use to show status. For example, these LEDs are
  // used by the "error()" function to indicate that something has
  // gone very wrong.
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);
  
  setupGPS();
  setupSDCard();
  
  // Pause for one second.
  delay(1000);
  
}

void loop()
{
  // Read a character from the GPS device over the serial port.
  if (gpsGetCharacter()) {
    // Verify the checksum.
    if (gpsChecksumIsOK()) {
      // Verify that we got a fix and that we got RMC (basic location) data.
      if (gpsGotRMCData()) {
        // Try to write the basic location data to the SD card.
        sdWriteGPSData();
      }
    }
  }
}

/ / Geo-caching

The Traveling Geocache

/*

 
This software is licensed under the terms of the Creative
Commons "Attribution Non-Commercial Share Alike" license, version
3.0, which grants the limited right to use or modify it NON-
COMMERCIALLY, so long as appropriate credit is given and
derivative works are licensed under the IDENTICAL TERMS.  For
license details see

  http://creativecommons.org/licenses/by-nc-sa/3.0/
 
This source code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 
This sketch illustrates how one might implement a Traveling Geocache
that incorporates rudimentary aspects of the technology in Mikal 
Hart's Reverse Geocache(tm) puzzle.
 
"Reverse Geocache" is a trademark of Mikal Hart.

For supporting libraries and more information see 

  http://arduiniana.org.
*/

#include <PWMServo.h>
#include <NewSoftSerial.h>
#include <TinyGPS.h>
#include <EEPROM.h>
#include <LiquidCrystal.h>

/* Pin assignments for the Traveling Geocache */
static const int GPSrx = 2, GPStx = 3;// I use this while connecting the ttl TX gps wire to pin 2. It works perfectly. Don't mess with it.
static const int LCD_Enable = 11, LCD_RS = 10, LCD_RW = 7;//LCD pins
static const int LCD_DB4 = 6, LCD_DB5 = 5, LCD_DB6 = 4, LCD_DB7 = 8;//LCD pins
static const int relay_switch_off = 14; // 5v relay switch control is connected to the arduino on pin 14 (analogue 0)
static const int servo_control = 9;// pin 9 is connected to the signal wire of the servo
static const int LED_pin = 12;

/* These values should be adjusted according to your needs */
static const int CLOSED_ANGLE = 140; // degrees. These angles should not need modification as long as the box is functioning correctly.
static const int OPEN_ANGLE = 20; // degrees
static const float DEST_LATITUDE = 42.3591; // change these coordinates to the new destination
static const float DEST_LONGITUDE = -71.0498;
static const int RADIUS = 50; // meters. This is how close you have to be for the box to open. Adjust as needed.

/* Fixed values should not need changing */
static const int DEF_ATTEMPT_MAX = 50;
static const int EEPROM_OFFSET = 100;

/* The basic objects needed */
NewSoftSerial nss(GPSrx, GPStx);
LiquidCrystal lcd(LCD_RS, LCD_RW, LCD_Enable, LCD_DB4, LCD_DB5, LCD_DB6, LCD_DB7);
TinyGPS tinygps; 
int attempt_counter;
PWMServo servo;

/* A helper function to display messages of a specified duration */
void Msg(LiquidCrystal &lcd, const char *top, const char *bottom, unsigned long del)
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(top);
  lcd.setCursor(0, 1);
  lcd.print(bottom);
  delay(del);
}

/* The Arduino setup() function */
void setup()
{
  /* attach servo motor */
  servo.attach(servo_control);

  /* establish a debug session with a host computer */
  Serial.begin(115200);

  /* establish communications with the GPS module */
  nss.begin(4800);

  /* establish communication with 16x2 LCD */
  lcd.begin(16,2); // this for an 16x2 LCD -- adjust as needed 
  
  /* Make sure Relay switch pin is OUTPUT and HIGH */
  pinMode(relay_switch_off, OUTPUT);
  digitalWrite(relay_switch_off, HIGH);
  
  /* make sure motorized latch is closed */
  servo.write(CLOSED_ANGLE); 
  
  /* read the attempt counter from the EEPROM */
  attempt_counter = EEPROM.read(EEPROM_OFFSET);
  if (attempt_counter == 0xFF) // brand new EEPROM?
    attempt_counter = 0;

  /* increment it with each run */
  ++attempt_counter;

  /* Greeting */
  Msg(lcd, "     DON'T", "     PANIC!", 2000);
  lcd.clear();
  Msg(lcd, "NAME OF USER", "       =)", 2000);// Insert the name of the new recipient here
  lcd.clear();
  Msg(lcd, "    Welcome", "     to the", 2000);
  lcd.clear();
  Msg(lcd, "Traveling", "Geocache!", 3000);
  

  /* Game over? */
  if (attempt_counter >= DEF_ATTEMPT_MAX)
  {
    Msg(lcd, "Sorry! No more", "attempts allowed!", 2000);
    lcd.clear();
    Msg(lcd, "your website", "here", 5000); // If you run out of turns you can go to the support website where you could explain the secret backdoor or ask that the box be returned for repairs
    
    PowerOff();
  }

  /* Print out the attempt counter */
  Msg(lcd, "    This is", "    attempt", 2000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(attempt_counter);
  lcd.print(" of "); 
  lcd.print(DEF_ATTEMPT_MAX);
  delay(2000);

  /* Save the new attempt counter */
  EEPROM.write(EEPROM_OFFSET, attempt_counter);

  Msg(lcd, "((((Seeking))))", "((((Signal.))))", 0);
}

/* The Arduino loop() function */
void loop()
{
  /* Has a valid NMEA sentence been parsed? */
  if (nss.available() && tinygps.encode(nss.read()))
  {
    float lat, lon;
    unsigned long fix_age;

    /* Have we established our location? */
    tinygps.f_get_position(&lat, &lon, &fix_age);
    if (fix_age != TinyGPS::GPS_INVALID_AGE)
    {
      /* Calculate the distance to the destination */
      float distance_meters = TinyGPS::distance_between(lat, lon, DEST_LATITUDE, DEST_LONGITUDE);

      /* Are we close?? */
      if (distance_meters <= RADIUS)
      {
        Msg(lcd, "     ACCESS", "    GRANTED!", 2000);
        lcd.clear();
        Msg(lcd, " WELCOME TO", "DESTINATION", 2000);// Insert the name of the destination here
        servo.write(OPEN_ANGLE);
        delay(2000);
        tone(16, 659, 200);// Play a victory tune! on pin 16 (Analogue 2) tone(PIN# of speaker connection, frequency, duration in miliseconds)
        delay(400);
        tone(16, 659, 100);
        delay(200);
        tone(16, 659, 100);
        delay(200);
        tone(16, 1319, 200);
        delay(400);
        tone(16, 1319, 200);
        delay(400);
        tone(16, 1760, 750);
        delay(1500);
      }

      /* Nope.  Print the distance. */
      else
      {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Distance");
        lcd.setCursor(0, 1);
        if (distance_meters < 1000)
        {
          lcd.print((int)distance_meters);
          lcd.print(" m.");
        }

        else
        {
          lcd.print((int)(distance_meters / 1000));
          lcd.print(" km.");
        }
        delay(4000);
        Msg(lcd, "     Access", "     Denied!", 2000);
      }

      PowerOff();
    }
  }

  /* Turn off after 5 minutes */
  if (millis() >= 300000)
    PowerOff();
}

/* Called to shut off the system using the Pololu switch */
void PowerOff()
{
  Msg(lcd, "    Powering", "      Off!", 2000);
  lcd.clear(); 
  
  /* Bring relay switch control pin LOW to turn off */
  digitalWrite(relay_switch_off, LOW);

  /* This is the back door.  If we get here, then the battery power */
  /* is being bypassed by the USB port.  We'll wait a couple of */
  /* minutes and then grant access. */
  delay(120000);
  servo.write(OPEN_ANGLE); // and open the box 

  /* Reset the attempt counter */
  EEPROM.write(EEPROM_OFFSET, 0); 
  
  /* Leave the latch open for 10 seconds */
  delay(10000); 

  /* And then seal it back up */
  servo.write(CLOSED_ANGLE); 

  /* Exit the program for real */
  exit(1);
}

  elighcash
  
  /*Code modified from Lady Ada's GPS shield code at http://www.ladyada.net/make/gpsshield
This code gets a fix on the GPS, does some simple calculations, and tells you how far away from 
a preset destination you are currently standing.  

The idea for this project is directly lifted from an AWESOME wedding gift and is detailed at 
http://arduiniana.org/projects/the-reverse-geo-cache-puzzle/

Calculation help provided by the following sites:
http://www.csgnetwork.com/gpsdistcalc.html
http://www.meridianworlddata.com/Distance-Calculation.asp

The code below doesn't stop reporting position until the unit is powered down.  I intend to make changes
so that is it more like the arduiniana project and limits the number of times that you can check the 
distance.

Once you arrive at the destination, nothing special really happens in this code, but I leave that open
to you.  Arduiniana used the arrival code to turn a servo that he has modified into a locking system on 
a decorative box.  Only once you arrived at the destination would the box open! Sweet.

The Sparkfun Serial LCD prints some garbage at times, probably because of the NewSoftSerial data
and the data coming from the GPS unit.  No big deal.

There are parts of this code that are not really used but could be incorporated into a logging system
so that you could go back later and see when the user pressed the button to check location.
Examples of unused data are time, month, year, groundspeed, and track angle.

*/
//TX should connect to pin 2, RX connects to pin 3 and PWR connects to pin 4.
// Sparkfun Serial LCD 16x2 was used and is connected to digital pin 7


#include <NewSoftSerial.h>
#include <math.h> // (no semicolon)
#include <SoftwareSerial.h>
#include "SparkFunSerLCD.h"
SparkFunSerLCD led(7,2,16);

NewSoftSerial mySerial =  NewSoftSerial(2, 3);
#define powerpin 4

#define GPSRATE 4800
//#define GPSRATE 38400


// GPS parser for 406a
#define BUFFSIZ 90 // plenty big
char buffer[BUFFSIZ];
char *parseptr;
char buffidx;
char GPSstatus;
uint8_t hour, minute, second, year, month, date;
uint32_t latitude, longitude;
uint8_t groundspeed, trackangle;
char latdir, longdir;
char status;
int velocity, angle, distance, distanceDec, Atimes, kmtimes;
long lat, lon, lattemp, lontemp;
float latdeg, londeg, x, y, km;

/*Enter your destination next.  
The easy way to find it is to go to google.com/maps and center the map on
the location you want as your destination.  Then enter the following into 
the address bar and you will get the values you need in GPS degrees decimal
to enter below.  

Enter the following into the address bar:

javascript:void(prompt('',gApplication.getMap().getCenter()));

Credit for the above javascript line goes to - http://www.tech-recipes.com/rx/2403/google_maps_get_latitude_longitude_values/

*/

//The Latitude/Longitude below is a shopping center in my home town, Diamond Bar, CA.
float destinationLat = 33.97570724099378;
float destinationLon = -117.83733308315277;
float threshold = 0.1;  //this is how close in km the unit has to be before it executes the arrival code.  
                        //For instance, a 1.0 would mean that the arrival code would execute within a 1km circle of the destination.

void printDouble( double val, unsigned int precision){
// prints val with number of decimal places determine by precision
// NOTE: precision is 1 followed by the number of zeros for the desired number of decimial places
// example: printDouble( 3.1415, 100); // prints 3.14 (two decimal places)

    Serial.print (int(val));  //prints the int part
    Serial.print("."); // print the decimal point
    unsigned int frac;
    if(val >= 0)
     frac = (val - int(val)) * precision;
    else
     frac = (int(val)- val ) * precision;
    Serial.println(frac,DEC) ;
}



void setup() 
{ 
  
  led.setup();
  delay(3000);
  led.bright (75);
  led.scrollLeft();
  
  if (powerpin) {
    pinMode(powerpin, OUTPUT);
  }
  Serial.begin(GPSRATE);
  mySerial.begin(GPSRATE);
   
  // prints title with ending line break 
  Serial.println("GPS parser"); 

   digitalWrite(powerpin, LOW);         // pull low to turn on!
} 


void loop() 
{ 

  
  uint32_t tmp;
  
   Serial.print("\n\rread: ");
  readline();
  
  // check if $GPRMC (global positioning fixed data)
  if (strncmp(buffer, "$GPRMC",6) == 0) {
    
    // hhmmss time data
    parseptr = buffer+7;
    tmp = parsedecimal(parseptr); 
    //some code to convert to Pacific Time
    if(tmp >= 80000){
    
      hour = (tmp / 10000) - 8;
    }
    else{
      hour = 16 + (tmp /10000); 
    }
    //end Pacific Time conversion
    
    minute = (tmp / 100) % 100;
    second = tmp % 100;
    
    parseptr = strchr(parseptr, ',') + 1;
    status = parseptr[0];
    parseptr += 2; 
// If your GPS does not have a lock yet then...    
if(status != 'A'){    
  Serial.println("GPS is locating you");
  led.empty();
  led.at(1,1,"GPS is locating you");
  }
  
// If the lock is less than 3 seconds old (used because the first few A lock data sets sometimes are still messed up
else if(Atimes < 2){
Serial.println("");
Serial.println("Almost Locked On"); 
led.empty();
led.at(1,1,"Almost Locked On");
Atimes += 1;
} 
// If the lock is money, then do this    
else{  
   Serial.println("");
   Serial.print("GPS Status is: ");
   Serial.println(status);   
    
   
    // grab latitude & long data
    // latitude
    latitude = parsedecimal(parseptr);
    if (latitude != 0) {
      latitude *= 10000;
      
      parseptr = strchr(parseptr, '.')+1;
      latitude += parsedecimal(parseptr);
      
      // This next conversion is only to display the long variable on the Sparkfun LCD screen.  I couldn't display the floats
      lat = (long) latitude;
      
      // The next two lines are used to convert the latitude data in GPS output into Degrees.  The math for this came from http://www.csgnetwork.com/gpsdistcalc.html    
      lattemp = (lat / 1000000) * 1000000;
      latdeg = (lattemp / 1000000.0) + ((lat - lattemp) / 600000.0); 
      
      if (latdir == 'S'){
      latdeg = -latdeg;
      }
    }
    parseptr = strchr(parseptr, ',') + 1;
    // read latitude N/S data
    if (parseptr[0] != ',') {
      latdir = parseptr[0];
    }
    
    //Serial.println(latdir);
    
    // longitude
    parseptr = strchr(parseptr, ',')+1;
    longitude = parsedecimal(parseptr);
    if (longitude != 0) {
      longitude *= 10000;
      
      parseptr = strchr(parseptr, '.')+1;
      longitude += parsedecimal(parseptr);
      // Again converting to a long in order to display on the Sparkfun Serial LCD
      lon = (long) longitude;
      // Again converting from GPS coordinates into Degrees Decimal
      lontemp = (lon / 1000000) * 1000000;
      londeg = (lontemp / 1000000.0) + ((lon - lontemp) / 600000.0); 
      if (longdir == 'W'){
      londeg = -londeg;
      }
    }
    parseptr = strchr(parseptr, ',')+1;
    // read longitude E/W data
    if (parseptr[0] != ',') {
      longdir = parseptr[0];
    }
    

    // groundspeed
    parseptr = strchr(parseptr, ',')+1;
    groundspeed = parsedecimal(parseptr);
    velocity = (int) groundspeed;
    // track angle
    parseptr = strchr(parseptr, ',')+1;
    trackangle = parsedecimal(parseptr);
    angle = (int) trackangle;

    // date
    parseptr = strchr(parseptr, ',')+1;
    tmp = parsedecimal(parseptr); 
    //calculate date but adjust by 1 day less if the hour is after 16:00 since the GPS outputs GMT and I want PST
    if(hour > 16) {
     date = (tmp / 10000) - 1; 
    }
    else{
    date = tmp / 10000;
    }
    month = (tmp / 100) % 100;
    year = (tmp % 100) + 2000;
    
    //distance between location and destination - calculation help came from http://www.meridianworlddata.com/Distance-Calculation.asp
      //rough distance measurement is this first block     
    x = 111.2057 * (destinationLat - latdeg);
    y = 85.2952 * (destinationLon - londeg);
    km = sqrt((x * x) + (y * y));
    
      //more accurate distance measurement but requires more computation time and doesn't really seem to matter much for my purposes
    //km = 6378.7 * acos(sin(latdeg/57.2958) * sin(destinationLat/57.2958) + cos(latdeg/57.2958) * cos(destinationLat/57.2958) * cos((destinationLon/57.2958) - (londeg/57.2958)));
    
    //reformatting the km variable into integers to display on the Sparkfun Serial LCD
    //since I had troubles printing decimals to it
    distance = km;
    distanceDec = (km * 100) - (distance * 100);
    
    //This section is the ADAFRUIT code that Serial prints some useful data but is not needed right now
  /*  Serial.print("\nTime: ");
    Serial.print(hour, DEC); Serial.print(':');
    Serial.print(minute, DEC); Serial.print(':');
    Serial.println(second, DEC);
    Serial.print("Date: ");
    Serial.print(month, DEC); Serial.print('/');
    Serial.print(date, DEC); Serial.print('/');
    Serial.println(year, DEC);
    
    Serial.print("Lat: "); 
    if (latdir == 'N')
       Serial.print('+');
    else if (latdir == 'S')
       Serial.print('-');

    Serial.print(latitude/1000000, DEC); Serial.print('\°', BYTE); Serial.print(' ');
    Serial.print((latitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
    Serial.print((latitude%10000)*6/1000, DEC); Serial.print('.');
    Serial.print(((latitude%10000)*6/10)%100, DEC); Serial.println('"');
   
    Serial.print("Long: ");
    if (longdir == 'E')
       Serial.print('+');
    else if (longdir == 'W')
       Serial.print('-');
    Serial.print(longitude/1000000, DEC); Serial.print('\°', BYTE); Serial.print(' ');
    Serial.print((longitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
    Serial.print((longitude%10000)*6/1000, DEC); Serial.print('.');
    Serial.print(((longitude%10000)*6/10)%100, DEC); Serial.println('"');
    
    Serial.print("Speed is:");
    Serial.println(groundspeed, DEC);
    Serial.print("Track Angle is:");
    Serial.println(trackangle, DEC);
    
    */
// kmtimes is a variable that I set up because the very first km distance from destination calculation was always way off.  
// I haven't spent the time to find out why and this was an easy workaround.  Lazy, I know.
if(kmtimes > 1){
    
    //My debugging data and testing if my integer variables worked.  This will print to the computer serial, not the sparkfun LCD
    Serial.print("Latitude in Degrees is:");
    printDouble(latdeg,10000);
    Serial.print("Longitude in Degrees is:");
    printDouble(londeg,10000);
    Serial.print("Distance from Destination is:");
    printDouble(km,100);
     
  // Uncomment this if you want basic speed data.  Velocity is in MPH.  This will go to the sparkfun LCD
   // led.at(1,1,"Speed:");
   // led.at(1,8,velocity);
    //led.at(2,1,"Angle:");
   // led.at(2,8,angle);  
   // led.empty();


// If you are within a certain distance of the final location, declared as threshold in the setup, then execute this code to open the box, light an LED, sing a song, etc.   
   if(km < threshold){
   // Arrival code below.  All that this does is print "Arrival" to the Sparkfun Serial LCD
     led.empty();
     led.at(1,1,"Arrival");
     led.at(2,1,"Password: 123456");
   }
   
// If you are not within the threshold distance, then tell the user how far they are   
   else{  
  led.empty();  //clear the screen
  led.at(1,1,"Incorrect. You ");
  led.at(2,1,"are ");
  led.at(2,5,distance);   //I have only allowed 3 digits for distance.  You will have to edit where this stuff prints if you want to make the distance more than 999.99km
                          // 1000km will only display as 100km.  9999999999km will only display 999km.  Just the first three digits.
  led.at(2,8,".");        //Put in a decimal point
  led.at(2,9,distanceDec);    //Display the integer we set up earlier to display the decimal points.  It will cut off at 2 decimals since my LCD screen is 16x2 only
  led.at(2,11,"km OFF");
   }
} 

// This runs if the count of kmtimes is less than declared in the if statement above.  Remember that this is because the first distance calculation gets messed up so I need it to 
// run through the entire program one more time at least before I will display any distance data to the user.
else{ 
//this iterates kmtimes integer up by one since the very first active fix wasn't giving me back the correct distance calculation
kmtimes +=1;
Serial.println("Calculating Distance");  //LOL, not really but it looks nice
led.empty();
led.at(1,1,"Calculating Distance");
delay(1000);
}   
   }    
  }
  }

  //Serial.println(buffer);

//other stuff that came with the ADAFRUIT Code and is used to chop up the NMEA data lines from the GPS
uint32_t parsedecimal(char *str) {
  uint32_t d = 0;
  
  while (str[0] != 0) {
   if ((str[0] > '9') || (str[0] < '0'))
     return d;
   d *= 10;
   d += str[0] - '0';
   str++;
  }
  return d;
}

void readline(void) {
  char c;
  
  buffidx = 0; // start at begninning
  while (1) {
      c=mySerial.read();
      if (c == -1)
        continue;
      Serial.print(c);
      if (c == '\n')
        continue;
      if ((buffidx == BUFFSIZ-1) || (c == '\r')) {
        buffer[buffidx] = 0;
        return;
      }
      buffer[buffidx++]= c;
  }
}

/ / navigation

/ / Assignment

Parsing the data

/ / Geo-caching

/ / Dispensing

/ / Instructions