camera/NMEA.h

Go to the documentation of this file.

#ifndef _NMEA_H_
#define _NMEA_H_

/*
   NMEA.h - Class encapsulating NMEA message strings.

   The NMEA class is an abstract base class used to represent NMEA sentence (message)
   strings. Each different NMEA sentence has an array of Field objects, each 
   of which represents one field (token) in the sentence.
   NMEA declares methods to set various types of fields, get Fields, 
   calculate checksums, and generate the NMEA string (an abstract method).
   Subclasses are expected to provide methods for setting their Field members 
   (which should enforce type checking and call the setField methods in NMEA),
   and implement the toString() method.

   Currently GPGGA and GPRMC message types are implemented.

   NMEA does not currently implement parse methods (to read in NMEA from a 
   string), since it was developed to synthesize NMEA strings.

  copyright MBARI 2008 
  author k. headley
*/

/****************************************************************************/
/* Copyright (c) 2008 MBARI                                                 */
/* MBARI Proprietary Information. All rights reserved.                      */
/****************************************************************************/
/* Summary  :                                                               */
/* Filename : NMEA.h                                                        */
/* Author   : K Headley                                                     */
/* Project  : Benthic Imaging AUV                                           */
/* Created  : 04/01/2008                                                    */
/****************************************************************************/
/* Modification History:                                                    */
/*  $Id: NMEA.h,v 1.1 2008/07/15 18:39:29 headley Exp $   */
/*  $Name:  $ */
/****************************************************************************/

#ifdef _QNX
#include <strstream.h>
#include <time.h>
#include <iostream.h>
#include <iomanip.h>
#else
#include <iostream>
#include <iomanip>
#include <sstream>
#include <ctime>
#endif

#ifndef _QNX
using namespace std;
#endif

#define MAX_NMEA_NAME 7

#define MAX_NMEA_FIELDS 32

#define MAX_NMEA_LEN 128


class Field{
  friend ostream& operator<<(ostream& output, const Field& n);
public:
  typedef enum FIELD_TYPES {INT=0,UINT,DOUBLE,UCHAR,CHAR,PCHAR,TIMET,DATET} FieldType;
  Field();
  Field(char *value);
  Field(char value);
  Field(int value);
  Field(unsigned int value);
  Field(double value);
  Field(unsigned char value);
  Field(time_t value);
  FieldType getType();
  char *pcharValue();
  int intValue();
  unsigned int uintValue();
  unsigned char ucharValue();
  double doubleValue();
  time_t timeValue();
  void setValue(int value);
  void setValue(unsigned int value);
  void setValue(char *value);
  void setValue(char value);
  void setValue(unsigned char value);
  void setValue(double value);
  void setValue(time_t value);
  const char *toString()const{
#ifdef _QNX
    ostrstream outs;
    outs << *this <<ends;
    return outs.str();
#else
    ostringstream outs;
    outs << *this;
    return outs.str().c_str();
#endif
  } 

 private:
  FieldType _type;
  char*_name;
  char *_pcharValue;
  char _charValue;
  int _intValue;
  unsigned int _uintValue;
  unsigned char _ucharValue;
  double _doubleValue;
  time_t _timeValue;

};/* class Field */

class InvalidNMEAException {
 public:
  char *message;
  InvalidNMEAException(char *m){message=m;}
  const char *msg(){return message;}
};

class NMEA{

 public:
  typedef enum MESSAGE_TYPES {t_GPGGA=0,t_GPRMC,t_GPGLL,
                              t_GPGSV,t_GPGSA,t_GPMSS,
                              t_GPVTG,tGPZDA,t_UNKNOWN}MessageType;
  enum FIELDS {FIELD_0=0,FIELD_1,FIELD_2,FIELD_3,
               FIELD_4,FIELD_5,FIELD_6,FIELD_7,
               FIELD_8,FIELD_9,FIELD_10,FIELD_11,
               FIELD_12,FIELD_13,FIELD_14,FIELD_15,
               FIELD_16,FIELD_17,FIELD_18,FIELD_19,
               FIELD_20,FIELD_21,FIELD_22,FIELD_23,
               FIELD_24,FIELD_25,FIELD_26,FIELD_27,
               FIELD_28,FIELD_29,FIELD_30,FIELD_31};

  NMEA();
  MessageType getType();
  Field *getField(NMEA::FIELDS index);
  void setField(NMEA::FIELDS field,int value);
  void setField(NMEA::FIELDS field,unsigned int value);
  void setField(NMEA::FIELDS field,char *value);
  void setField(NMEA::FIELDS field,char value);
  void setField(NMEA::FIELDS field,unsigned char value);
  void setField(NMEA::FIELDS field,double value);
  void setField(NMEA::FIELDS field,time_t value);
  //virtual const char *toString()=0;
  unsigned short int checksum(const char *nmeaString)const{
    const char *cp=nmeaString;//.c_str();
    char *bp, *ep;
    short unsigned int ret;

    // set begin and end pointers
    bp=strstr(cp,"$");
    ep=strstr(cp,"*");

    // throw exception if the start or end 
    // characters not found
    if(bp==NULL || ep==NULL){
      throw InvalidNMEAException("Missing delimiter * or $");
    }
    // start at character after '$'
    bp++;
    ret=0;
    // compute XOR of all bytes until '*'
    while(bp<ep){
      ret ^= (short unsigned int) (*bp);
      bp++;
    }
    return ret;
  }

 protected:
  unsigned int _nFields;
  MessageType  _type;
  Field _fields[MAX_NMEA_FIELDS];
  
 private:

};/* class NMEA */

class GPGGA : public NMEA{
  friend ostream& operator<<(ostream& output, const GPGGA& n);
public:

  enum FIELDS {GGAMSG=NMEA::FIELD_0,GGATIME,
               GGALATD,GGALATM,GGALATH,
               GGALOND,GGALONM,GGALONH,
               GGAQUAL,GGASIU,GGAHDOP,
               GGAALT,GGAALTU,
               GGAGEOH,GGAGEOHU,
               GGADUPT,GGADRID,GGACHK};
  GPGGA();
  int setTIME(time_t time);
  int setLATD(int latd);
  int setLATM(double latm);
  int setLATH(char lath);
  int setLOND(int lond);
  int setLONM(double lonm);
  int setLONH(char lonh);
  int setQUAL(int qual);
  int setHDOP(double hdop);
  int setALT(double alt);
  int setALTU(char altu);
  int setSIU(int siu);
  int setGEOH(double alt);
  int setGEOHU(char geohu);
  int setDUPT(int dupt);
  int setDRID(int drid);
  virtual const char *toString();

 private:

};/* class GPGGA */
class GPRMC : public NMEA{
  friend ostream& operator<<(ostream& output, const GPRMC& n);
public:
  enum FIELDS {RMCMSG=NMEA::FIELD_0,RMCTIME,RMCSTAT,
               RMCLATD,RMCLATM,RMCLATH,
               RMCLOND,RMCLONM,RMCLONH,
               RMCSOG,RMCCOG,RMCDATE,
               RMCMVM,RMCMVD,RMCCHK};

  GPRMC();
  int setTIME(time_t time);
  int setSTAT(char stat);
  int setLATD(int latd);
  int setLATM(double latm);
  int setLATH(char lath);
  int setLOND(int lond);
  int setLONM(double lonm);
  int setLONH(char lonh);
  int setSOG(double sog);
  int setCOG(double cog);
  int setDATE(time_t date);
  int setMVM(double nvn);
  int setMVD(char mvd);
  virtual const char *toString();

 private:

};/* class GPRMC */
#endif /*_NMEA_H_*/

---