nmea_gps.hpp

Go to the documentation of this file.

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2016 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once

#include <atomic>
#include <iostream>
#include <map>
#include <list>
#include <mutex>
#include <queue>
#include <cstdlib>
#include <string>
#include <thread>
#include <unistd.h>
#include <utility>
#include <vector>

#include "nmea_gps.h"

namespace upm {
    class NMEAGPS;

    struct coord_DD {
        double latitude = 0.0;
        double longitude = 0.0;
        std::string __str__();
    };

    struct satellite {
        std::string prn;
        int elevation_deg;
        int azimuth_deg;
        int snr;
        satellite():satellite("", 0, 0, 0){}
        satellite(const std::string& sprn, int elevation, int azimuth, int snr):
            prn(sprn), elevation_deg(elevation), azimuth_deg(azimuth), snr(snr) {}
        std::string __str__();
    };

    struct nmeatxt {
        int severity;
        std::string message;
        nmeatxt():nmeatxt(0, "") {}
        nmeatxt(int severity, const std::string& message):
                severity(severity), message(message){}
        std::string __str__();
    };

    enum class gps_fix_quality {
        no_fix = 0,
        fix_sp,
        fix_dp,
        fix_pps,
        fix_rtk,
        fix_frtk,
        fix_dr,
        fix_manual,
        fix_simulation
    };

    struct gps_fix {
        coord_DD coordinates;
        std::string time_utc = std::string("");
        gps_fix_quality quality = gps_fix_quality::no_fix;
        uint8_t satellites = 0;
        float hdop = 0.0;
        float altitude_meters = 0.0;
        float geoid_height_meters = 0.0;
        float age_seconds = 0.0;
        std::string station_id = std::string("");
        bool valid = false;
        bool chksum_match = false;
        std::string __str__();
    };

    class NMEAGPS {
        public:

            NMEAGPS(unsigned int uart, unsigned int baudrate,
                    int enable_pin);

            NMEAGPS(const std::string& uart, unsigned int baudrate);

            NMEAGPS(unsigned int bus, uint8_t addr);

            ~NMEAGPS();

            std::string readStr(size_t size);

            int writeStr(const std::string& buffer);

            void enable(bool enable);

            void setBaudrate(unsigned int baudrate);

            bool dataAvailable(unsigned int millis);

            size_t getMaxQueueDepth();

            size_t setMaxQueueDepth(size_t depth);

            void parseStart();

            void parseStop();

            bool isRunning() {return _running;}

            gps_fix getFix();

            std::string getRawSentence();

            nmeatxt getTxtMessage();

            size_t fixQueueSize();

            size_t rawSentenceQueueSize();

            size_t txtMessageQueueSize();

            void parseNMEASentence(const std::string& sentence);

            std::vector<satellite> satellites();

            double sentencesPerSecond();

            double bytesPerSecond();

            std::string __str__();
        protected:
            nmea_gps_context m_nmea_gps;

        private:
            NMEAGPS(const NMEAGPS&) = delete;
            NMEAGPS &operator=(const NMEAGPS&) = delete;

            std::thread _parser;

            void _parse_thread();

            std::atomic<bool> _running;

            void _parse_gpgga(const std::string& string);
            void _parse_gpgsv(const std::string& string);
            void _parse_gpgll(const std::string& string);
            void _parse_gptxt(const std::string& string);

            using fp = void (NMEAGPS::*)(const std::string &);
            const std::map<std::string, fp> nmea_2_parser =
            {
                {"GPGGA", &NMEAGPS::_parse_gpgga},
                {"GPGSV", &NMEAGPS::_parse_gpgsv},
                {"GPGLL", &NMEAGPS::_parse_gpgll},
                {"GPTXT", &NMEAGPS::_parse_gptxt},
            };

            std::queue<std::string> _queue_nmea_sentence;
            std::mutex _mtx_nmea_sentence;

            std::queue<gps_fix> _queue_fix;
            std::mutex _mtx_fix;

            std::queue<nmeatxt> _queue_txt;
            std::mutex _mtx_txt;

            std::atomic<size_t> _maxQueueDepth;

            std::atomic<size_t> _sentences_since_start;

            std::atomic<size_t> _bytes_since_start;

            std::atomic<double> _seconds_since_start;

            std::list<satellite> _satlist;
            std::mutex _mtx_satlist;
    };
}