PositionSensor.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
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.
 
Library: Hardware
File: PositionSensor
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Device.h>
#include <NDEVR/StationModel.h>
#include <NDEVR/Deployment.h>
#include <NDEVR/GPSPoint.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/UUID.h>
#include <QObject>
namespace NDEVR
{
    class Deployment;
    class StationModel;
    class Effect;
    class OrientationSensor;
    class DistanceEncoder;
    
    /**--------------------------------------------------------------------------------------------------
    \brief A position sensor is a Device that determines the position of Hardware. This device might be
        a GPS or SLAM style logic device.
    **/
    class HARDWARE_API PositionSensor : public Device
    {
        Q_OBJECT
    public:
        PositionSensor(const Model& name, ProgressInfo* log, QObject* parent = nullptr);
        [[nodiscard]] virtual Vertex<3, fltp08> lastPosition() const;
        void setPosition(const Vertex<3, fltp08>& location);
        //Sensor Location
        [[nodiscard]] virtual Vertex<3, fltp08> sensorLocation() const { return m_sensor_location; }
        void setSensorLocation(const Vertex<3, fltp08>& location);
        void update();
        //GPS Options
        [[nodiscard]] virtual GNSSQuality gpsQuality() const { return GNSSQuality::e_invalid; };
        virtual bool requestUsingGPS(bool using_gps);
        virtual bool stationUsedForOffset() const { return true; }
        [[nodiscard]] virtual bool usingGPS() const { return m_using_gps; }
        //Station Options
        
        virtual bool requestDistanceEncoder(DistanceEncoder*) { return false; }
        //Deployment Options
        virtual void addDeploymentSegment(fltp08 distance) { UNUSED(distance); }
        virtual void removeDeploymentSegment(uint04 index = Constant<uint04>::Invalid) { UNUSED(index); }
        virtual void setVelocity(const Vector<3, fltp08>& velocity);
        virtual void setAcceleration(const Vector<3, fltp08>& acceleration);
#if NDEVR_STATION_MODEL
        virtual bool requestStation(const StationModel& model);
        [[nodiscard]] virtual const StationModel& station() const { return m_station_model; }
        [[nodiscard]] virtual StationModel& station() { return m_station_model; }
#endif
#if NDEVR_DEPLOYMENT
        virtual bool requestDeployment(const Deployment& deployment);
        [[nodiscard]] virtual const Deployment& deployment() const { return m_deployment; }
        [[nodiscard]] virtual Deployment& deployment() { return m_deployment; }
#endif
        [[nodiscard]] virtual DistanceEncoder* distanceEncoder() const { return nullptr; }
        [[nodiscard]] virtual Vector<3, fltp08> stdDev() const { return Constant<Vector<3, fltp08>>::Invalid; };
        [[nodiscard]] virtual OrientationSensor* orientationSensor() const { return nullptr; }
    signals:
        void deploymentSegmentAddedSignal();
        void deploymentSegmentRemovedSignal();
        void deploymentChangedSignal(UUID deployment);
        void stationChangedSignal(UUID station);
    protected:
#if NDEVR_STATION_MODEL
        StationModel m_station_model;
#endif
#if NDEVR_DEPLOYMENT
        Deployment m_deployment;
#endif
        bool m_using_gps;
        Time m_last_position_time;
        Vertex<3, fltp08> m_position;
        Vertex<3, fltp08> m_sensor_location;
        Vector<3, fltp08> m_velocity;
        Vector<3, fltp08> m_acceleration;
    };
    template class HARDWARE_API StringStream<GNSSQuality>;
}