GPSProvider.cpp

Go to the documentation of this file.

#include "GPSProvider.h"

#include <QDebug>

#include <math.h>

#include <apiCDD.h>

GPSProvider::GPSProvider()
{
}

GPSProvider::~GPSProvider()
{
}

void GPSProvider::getPosition()
{
    int rc; /* Return code. */

    struct gps_data_t gps_data; /* Data from GPS signal. */
    memset(&gps_data, 0, sizeof gps_data);
    if ((rc = gps_open(m_data.m_address.toStdString().c_str(), m_data.m_port.toStdString().c_str(), &gps_data)) == -1)
    {
        qDebug() << "code: " << rc << ", reason: ", gps_errstr(rc);
        m_data.m_heading = make_Heading();
        m_data.m_referencePosition = make_ReferencePosition();
        m_data.m_speed = make_Speed();
        getTimestamp();
        return;
    }
    gps_stream(&gps_data, WATCH_ENABLE | WATCH_JSON, NULL);

    while(true)
    {
        /* Wait for 100 milliseconds to receive data/ */
        if (gps_waiting (&gps_data, 1000000))
        {
            printf("Read GPS data\n");
            /* Read data. */
            if ((rc = gps_read(&gps_data)) == -1)
            {
                qDebug() << "error occured reading gps data. code: " << rc << ", reason: " << gps_errstr(rc);
                m_data.m_heading = make_Heading();
                m_data.m_referencePosition = make_ReferencePosition();
                m_data.m_speed = make_Speed();
                getTimestamp();
            } else
            {
                /* Feed data from the GPS receiver. */
                if ((gps_data.status == STATUS_FIX) &&
                        (gps_data.fix.mode == MODE_2D || gps_data.fix.mode == MODE_3D) &&
                        !isnan(gps_data.fix.latitude) &&
                        !isnan(gps_data.fix.longitude))
                {
                    m_data.m_referencePosition.altitude.altitudeValue = gps_data.fix.altitude * 100;
                    m_data.m_referencePosition.altitude.altitudeConfidence = getAltitudeConfidence(gps_data.fix.epv * 1000);
                    m_data.m_referencePosition.latitude = gps_data.fix.latitude * 10000000;
                    m_data.m_referencePosition.longitude = gps_data.fix.longitude * 10000000;
                    m_data.m_speed.speedValue = gps_data.fix.speed * 100;
                    if(isnan(gps_data.fix.eps))
                        m_data.m_speed.speedConfidence = SpeedConfidence_unavailable;
                    else
                    {
                        if((gps_data.fix.eps * 100) > SpeedConfidence_outOfRange)
                            m_data.m_speed.speedConfidence = SpeedConfidence_outOfRange;
                        else
                            m_data.m_speed.speedConfidence = gps_data.fix.eps;
                    }
                    m_data.m_heading.headingValue = gps_data.fix.track * 10;
                    if(isnan(gps_data.fix.epd))
                        m_data.m_heading.headingConfidence = HeadingConfidence_unavailable;
                    else
                    {
                        if((gps_data.fix.epd * 10) > HeadingConfidence_outOfRange)
                            m_data.m_heading.headingConfidence = HeadingConfidence_outOfRange;
                        else
                            m_data.m_heading.headingConfidence = gps_data.fix.epd * 10;
                    }
                    getTimestamp();
                    checkConstraints();
                    emit positionChanged();
                } else
                {
                    qDebug() << "no GPS data available";
                    m_data.m_heading = make_Heading();
                    m_data.m_referencePosition = make_ReferencePosition();
                    m_data.m_speed = make_Speed();
                    getTimestamp();
                }
            }
        }
        else
        {
            m_data.m_heading = make_Heading();
            m_data.m_referencePosition = make_ReferencePosition();
            m_data.m_speed = make_Speed();
            getTimestamp();
        }
    }
    printf("Leaving GPS\n");

    /* When you are done... */
    gps_stream(&gps_data, WATCH_DISABLE, NULL);
    gps_close (&gps_data);
}

AltitudeConfidence_t GPSProvider::getAltitudeConfidence(int epv)
{
    if(!epv || isnan(epv))
        return AltitudeConfidence_unavailable;
    if(epv < 10)
        return AltitudeConfidence_alt_000_01;
    if(epv < 20)
        return AltitudeConfidence_alt_000_02;
    if(epv < 50)
        return AltitudeConfidence_alt_000_05;
    if(epv < 100)
        return AltitudeConfidence_alt_000_10;
    if(epv < 200)
        return AltitudeConfidence_alt_000_20;
    if(epv < 500)
        return AltitudeConfidence_alt_000_50;
    if(epv < 1000)
        return AltitudeConfidence_alt_001_00;
    if(epv < 2000)
        return AltitudeConfidence_alt_002_00;
    if(epv < 5000)
        return AltitudeConfidence_alt_005_00;
    if(epv < 10000)
        return AltitudeConfidence_alt_010_00;
    if(epv < 20000)
        return AltitudeConfidence_alt_020_00;
    if(epv < 50000)
        return AltitudeConfidence_alt_050_00;
    if(epv < 100000)
        return AltitudeConfidence_alt_100_00;
    if(epv < 200000)
        return AltitudeConfidence_alt_200_00;
    return AltitudeConfidence_outOfRange;
}

void GPSProvider::execute()
{
    getPosition();
}

void GPSProvider::checkConstraints()
{
    constr_ReferencePosition(&(data().m_referencePosition));
    constr_Speed(&(data().m_speed));
    constr_Heading(&(data().m_heading));
    /*constr_TimestampIts(&(data().m_timestamp));*/
}