Gps.h

Go to the documentation of this file.

/*
   Copyright (C) 2018 SFini

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program 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.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
class MyDegrees
{
public:
   uint16_t predecimal; 
   uint32_t billionths; 
   bool     negative;   

public:
   MyDegrees();
   MyDegrees(const MyDegrees &myDegrees);

   void   clear();

   double value();
   bool   set(const String &data);
};

class MyLocation
{
friend class MyGps;
protected:
   MyDegrees latitude_;  
   MyDegrees longitude_; 

public:
   static double distanceBetween(double lat1, double long1, double lat2, double long2);
   static double courseTo(double lat1, double long1, double lat2, double long2);

public:
   void   clear();

   double latitude();
   double longitude();

   String longitudeString();
   String latitudeString();

   double distanceTo(MyLocation &location);
   double courseTo  (MyLocation &location);
};

class MyDate
{
friend class MyGps;
protected:
   int date; 
      
public:
   int year();
   int month();
   int day();

   MyDate() 
      : date(0)
   {
   }

   void clear();

   String dateString();
};

class MyTime
{
friend class MyGps;
protected:
  int time; 
  
public:
   int hour();
   int minute();
   int second();

   MyTime() 
      : time(0)
   {
   }
   MyTime(int t)
      : time(t)
   {
   }

   void clear();

   String timeString();

   operator int() {
      return time;
   }
};
  
class MyGps
{
public:
   bool       runStatus;         
   bool       fixStatus;         
   MyDate     date;              
   MyTime     time;              
   MyLocation location;          
   double     altitude;          
   double     speed;             
   double     course;            
   int        fixMode;           
   double     pdop;              
   double     hdop;              
   double     vdop;              
   int        satellitesInView;  
   int        satellitesUsed;    

protected:
   bool parse(bool   &b, const String &data);
   bool parse(int    &i, const String &data);
   bool parse(double &d, const String &data);
   
public:
   MyGps();

   void clear();

   bool setRunStatus       (const String &data);
   bool setFixStatus       (const String &data);
   bool setDateTime        (const String &data);
   bool setLatitude        (const String &data);
   bool setLongitude       (const String &data);
   bool setAltitude        (const String &data);
   bool setSpeed           (const String &data);
   bool setCourse          (const String &data);
   bool setFixMode         (const String &data);
   bool setHdop            (const String &data);
   bool setPdop            (const String &data);
   bool setVdop            (const String &data);
   bool setSatellitesInView(const String &data);
   bool setSatellitesUsed  (const String &data);

   String longitudeString  ();
   String latitudeString   ();
   String altitudeString   ();
   String kmphString       ();
   String satellitesString ();
   String courseString     ();

   bool   getAsGpsJson(char *gpsJson);
};

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

MyDegrees::MyDegrees()
   : predecimal(0)
   , billionths(0)
   , negative(false)
{
}

MyDegrees::MyDegrees(const MyDegrees &myDegrees)
   : predecimal(myDegrees.predecimal)
   , billionths(myDegrees.billionths)
   , negative(myDegrees.negative)
{
}

void MyDegrees::clear()
{
   predecimal = 0;
   billionths = 0;
   negative   = false;
}

double MyDegrees::value()
{
   double ret = predecimal + billionths / 1000000000.0;

   return negative ? -ret : ret;
}

bool MyDegrees::set(const String &data)
{
   const char *term          = data.c_str();
   uint32_t    multiplier    = 1000000000UL;
   uint32_t    leftOfDecimal = (uint32_t) atol(term);

   predecimal = (int16_t)leftOfDecimal;
   billionths = 0;

   while (isdigit(*term)) {
      ++term;
   }

   if (*term == '.') {
      while (isdigit(*++term)) {
         multiplier /= 10;
         billionths += (*term - '0') * multiplier;
      }
   }
   negative = false;
   return true;
}

void MyLocation::clear()
{
   latitude_.clear();
   longitude_.clear();
}

double MyLocation::distanceBetween(double lat1, double long1, double lat2, double long2)
{
   // returns distance in meters between two positions, both specified
   // as signed decimal-degrees latitude and longitude. Uses great-circle
   // distance computation for hypothetical sphere of radius 6372795 meters.
   // Because Earth is no exact sphere, rounding errors may be up to 0.5%.
   // Courtesy of Maarten Lamers
   double delta = radians(long1 - long2);
   double sdlong = sin(delta);
   double cdlong = cos(delta);
   lat1 = radians(lat1);
   lat2 = radians(lat2);
   double slat1 = sin(lat1);
   double clat1 = cos(lat1);
   double slat2 = sin(lat2);
   double clat2 = cos(lat2);
   delta = (clat1 * slat2) - (slat1 * clat2 * cdlong);
   delta = sq(delta);
   delta += sq(clat2 * sdlong);
   delta = sqrt(delta);
   double denom = (slat1 * slat2) + (clat1 * clat2 * cdlong);
   delta = atan2(delta, denom);
   return delta * 6372795;
}

double MyLocation::courseTo(double lat1, double long1, double lat2, double long2)
{
   // returns course in degrees (North=0, West=270) from position 1 to position 2,
   // both specified as signed decimal-degrees latitude and longitude.
   // Because Earth is no exact sphere, calculated course may be off by a tiny fraction.
   // Courtesy of Maarten Lamers
   double dlon = radians(long2 - long1);
   lat1 = radians(lat1);
   lat2 = radians(lat2);
   double a1 = sin(dlon) * cos(lat2);
   double a2 = sin(lat1) * cos(lat2) * cos(dlon);
   a2 = cos(lat1) * sin(lat2) - a2;
   a2 = atan2(a1, a2);
   if (a2 < 0.0)
   {
      a2 += TWO_PI;
   }
   return degrees(a2);
}

double MyLocation::latitude()
{
   return latitude_.value();
}

double MyLocation::longitude()
{
   return longitude_.value();
}

String MyLocation::longitudeString()
{
   return String(longitude(), 6);
}

String MyLocation::latitudeString()
{
   return String(latitude(), 6);
}

double MyLocation::distanceTo(MyLocation &to)
{
   return distanceBetween(latitude(), longitude(), to.latitude(), to.longitude());
}

double MyLocation::courseTo(MyLocation &to)
{
   return courseTo(latitude(), longitude(), to.latitude(), to.longitude());
}

void MyDate::clear()
{
   date = 0;
}

int MyDate::year()
{
   return date / 10000;
}

int MyDate::month()
{
   return (date / 100) % 100;
}

int MyDate::day()
{
   return date % 100;
}

String MyDate::dateString()
{
   return String(day()) + '-' + String(month()) + '-' + String(year());
}

void MyTime::clear()
{
   time = 0;
}

int MyTime::hour()
{
   return time / 10000;
}

int MyTime::minute()
{
   return (time / 100) % 100;
}

int MyTime::second()
{
   return time % 100;
}

String MyTime::timeString()
{
   return String(hour()) + ':' + String(minute()) + ':' + String(second());
}


MyGps::MyGps()
   : runStatus(false)
   , fixStatus(false)
   , altitude(0)
   , speed(0)
   , course(0)
   , fixMode(0)
   , hdop(0)
   , pdop(0)
   , vdop(0)
   , satellitesInView(0)
   , satellitesUsed(0)
{
}

void MyGps::clear()
{
   date.clear();
   time.clear();
   location.clear();
   runStatus        = false;
   fixStatus        = false;
   altitude         = 0.0;
   speed            = 0.0;
   course           = 0.0;
   fixMode          = 0;
   pdop             = 0.0;
   hdop             = 0.0;
   vdop             = 0.0;
   satellitesInView = 0;
   satellitesUsed   = 0;
}

bool MyGps::parse(bool &b, const String &data)
{
   if (data == F("0")) {
      b = false;
      return true;
   } else if (data == F("1")) {
      b = true;
      return true;
   }
   return false;
}

bool MyGps::parse(int &i, const String &data)
{
    i = atol(data.c_str());
    return true;
}

bool MyGps::parse(double &d, const String &data)
{
    d = atof(data.c_str());
    return true;
}

bool MyGps::setRunStatus(const String &data)
{
   return parse(runStatus, data);
}

bool MyGps::setFixStatus(const String &data)
{
   return parse(fixStatus, data);
}

bool MyGps::setDateTime(const String &data)
{
   parse(date.date, data.substring(0, 8));
   parse(time.time, data.substring(8));
   return true;
}

bool MyGps::setLatitude(const String &data)
{
   return location.latitude_.set(data);
}

bool MyGps::setLongitude(const String &data)
{
   return location.longitude_.set(data);
}

bool MyGps::setAltitude(const String &data)
{
   return parse(altitude, data);
}

bool MyGps::setSpeed(const String &data)
{
   return parse(speed, data);
}

bool MyGps::setCourse(const String &data)
{
   return parse(course, data);
}

bool MyGps::setFixMode(const String &data)
{
   return parse(fixMode, data);
}

bool MyGps::setPdop(const String &data)
{
   return parse(pdop, data);
}

bool MyGps::setHdop(const String &data)
{
   return parse(hdop, data);
}

bool MyGps::setVdop(const String &data)
{
   return parse(vdop, data);
}

bool MyGps::setSatellitesInView(const String &data)
{
   return parse(satellitesInView, data);
}

bool MyGps::setSatellitesUsed(const String &data)
{
   return parse(satellitesUsed, data);
}

String MyGps::longitudeString()
{
   return location.longitudeString();
}

String MyGps::latitudeString()
{
   return location.latitudeString();
}

String MyGps::altitudeString()
{
   return String(altitude, 0);
}

String MyGps::kmphString()
{
   return String(speed, 0);
}

String MyGps::satellitesString()
{
   return String(satellitesUsed);
}

String MyGps::courseString()
{
   return String(course);
}

bool MyGps::getAsGpsJson(char *gpsJson)
{
   if (fixStatus) {
      String gps;

      gps += "{";
      gps += "\"long\":\"" + longitudeString() + "\",";
      gps += "\"lat\":\""  + latitudeString()  + "\",";
      gps += "\"alt\":\""  + altitudeString()  + "\",";
      gps += "\"kmph\":\"" + kmphString()      + "\"";
      gps += "}";

      gps.toCharArray(gpsJson, (gps.length() + 1));
      return true;
   }
   return false;
}