gps.hxx

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: CC0-1.0
 * 
 * gps.hxx - distance-measuring equipment.
 * Written by David Megginson, started 2003.
 * 
 * This file is in the Public Domain and comes with no warranty.
*/
 
#pragma once
 
#include <cassert>
#include <memory>
 
#include <simgear/props/props.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
#include <simgear/props/tiedpropertylist.hxx>
 
#include <Navaids/positioned.hxx>
#include <Navaids/FlightPlan.hxx>
#include <Instrumentation/rnav_waypt_controller.hxx>
 
#define FG_210_COMPAT 1

class GPS : public SGSubsystem,
            public flightgear::RNAV,
            public flightgear::FlightPlan::Delegate
{
public:
    GPS (SGPropertyNode *node, bool defaultGPSMode = false);
    GPS ();
    virtual ~GPS();
 
  // SGSubsystem interface
    void init() override;
    void reinit() override;
    void bind() override;
    void unbind() override;
    void update (double delta_time_sec) override;
    void shutdown() override;
 
    // Subsystem identification.
    static const char* staticSubsystemClassId() { return "gps"; }
 
  // RNAV interface
    SGGeod position() override;
    double trackDeg() override;
    double groundSpeedKts() override;
    double vspeedFPM() override;
    double magvarDeg() override;
    double selectedMagCourse() override;
    double overflightDistanceM() override;
    double overflightArmDistanceM() override;
    double overflightArmAngleDeg() override;
    bool canFlyBy() const override;
    double maxFlyByTurnAngleDeg() const override;
 
    std::optional<LegData> previousLegData() override;
 
    std::optional<double> nextLegTrack() override;
 
    double turnRadiusNm(double groundSpeedKnots) override;
private:
    friend class SearchFilter;
 
    void setFlyByMaxTurnAngle(double maxAngle);

    class Config
    {
    public:
        Config();
 
        void bind(GPS* aOwner, SGPropertyNode* aCfg);
 
        bool turnAnticipationEnabled() const { return _enableTurnAnticipation; }

        double turnRateDegSec() const        { return _turnRate; }

        double overflightDistanceNm() const { return _overflightDistance; }
        double overflightArmDistanceNm() const { return _overflightArmDistance; }
        double overflightArmAngleDeg() const { return _overflightArmAngle; }

        double waypointAlertTime() const     { return _waypointAlertTime; }
 
        bool requireHardSurface() const      { return _requireHardSurface; }
 
        bool cdiDeflectionIsAngular() const  { return (_cdiMaxDeflectionNm <= 0.0); }
 
        double cdiDeflectionLinearPeg() const
        {
            assert(_cdiMaxDeflectionNm > 0.0);
            return _cdiMaxDeflectionNm;
        }
 
        bool driveAutopilot() const          { return _driveAutopilot; }
 
        bool courseSelectable() const        { return _courseSelectable; }

        bool followLegTrackToFix() const      { return _followLegTrackToFix; }
 
        
        bool delegateDoesSequencing() const    { return _delegateSequencing; }
 
        double maxFlyByTurnAngleDeg() const { return _maxFlyByTurnAngle; }
 
        void setMaxFlyByTurnAngle(double deg)
        {
            _maxFlyByTurnAngle = deg;
        }
 
    private:
        bool _enableTurnAnticipation;
 
        // desired turn rate in degrees per second
        double _turnRate;
 
        // distance from waypoint to arm overflight sequencing (in nm)
        double _overflightDistance;
 
        // distance from waypoint to arm overflight sequencing (in nm)
        double _overflightArmDistance;
 
        //abs angle from course to waypoint to arm overflight sequencing (in deg)
        double _overflightArmAngle;
 
        // time before reaching a waypoint to trigger annunciator light/sound
        // (in seconds)
        double _waypointAlertTime;
 
        // should we require a hard-surfaced runway when filtering?
        bool _requireHardSurface;
 
        double _cdiMaxDeflectionNm;
 
        // should we drive the autopilot directly or not?
        bool _driveAutopilot;
 
        // is selected-course-deg read to set desired-course or not?
        bool _courseSelectable;
 
        // do we fly direct to fixes, or follow the leg track closely?
        bool _followLegTrackToFix;
        
        // do we handle waypoint sequencing ourselves, or let the delegate do it?
        // default is we do it, for backwards compatability
        bool _delegateSequencing = false;
 
        double _maxFlyByTurnAngle = 90.0;
    };
 
    class SearchFilter : public FGPositioned::Filter
    {
    public:
        virtual bool pass(FGPositioned* aPos) const;
 
        virtual FGPositioned::Type minType() const;
        virtual FGPositioned::Type maxType() const;
    };

    void clearOutput();
 
    void updateBasicData(double dt);
 
    void updateTrackingBug();
    void updateRouteData();
    void driveAutopilot();
  
    void wp1Changed();
 
    void clearScratch();

    bool isScratchPositionValid() const;
    FGPositionedRef positionedFromScratch() const;
 
#if FG_210_COMPAT
    void setScratchFromPositioned(FGPositioned* aPos, int aIndex);
    void setScratchFromCachedSearchResult();
    void setScratchFromRouteWaypoint(int aIndex);

    void addAirportToScratch(FGAirport* aAirport);
 
    FGPositioned::Filter* createFilter(FGPositioned::Type aTy);

    void performSearch();
 
    // command handlers
    void loadRouteWaypoint();
    void loadNearest();
    void search();
    void nextResult();
    void previousResult();
    void defineWaypoint();
    void insertWaypointAtIndex(int aIndex);
    void removeWaypointAtIndex(int aIndex);
    void commandExitHold();
    
    // tied-property getter/setters
    double getScratchDistance() const;
    double getScratchMagBearing() const;
    double getScratchTrueBearing() const;
    bool getScratchHasNext() const;
 
#endif
 
    // command handlers
    void selectLegMode();
    void selectOBSMode(flightgear::Waypt* waypt);
    void directTo();
 
    // tied-property getter/setters
    void setCommand(const char* aCmd);
    const char* getCommand() const { return ""; }
 
    const char* getMode() const { return _mode.c_str(); }
    bool getScratchValid() const { return _scratchValid; }
 
    double getSelectedCourse() const { return _selectedCourse; }
    void setSelectedCourse(double crs);
    double getDesiredCourse() const { return _desiredCourse; }
 
    double getCDIDeflection() const;
 
    double getLegDistance() const;
    double getLegCourse() const;
    double getLegMagCourse() const;
 
    double getTrueTrack() const { return _last_true_track; }
    double getMagTrack() const;
    double getGroundspeedKts() const { return _last_speed_kts; }
    double getVerticalSpeed() const { return _last_vertical_speed; }
 
    const char* getWP0Ident() const;
    const char* getWP0Name() const;
 
    bool getWP1IValid() const;
    const char* getWP1Ident() const;
    const char* getWP1Name() const;
 
    double getWP1Distance() const;
    double getWP1TTW() const;
    const char* getWP1TTWString() const;
    double getWP1Bearing() const;
    double getWP1MagBearing() const;
    double getWP1CourseDeviation() const;
    double getWP1CourseErrorNm() const;
    bool getWP1ToFlag() const;
    bool getWP1FromFlag() const;
 
    // true-bearing-error and mag-bearing-error
 
    double computeTurnRadiusNm(double aGroundSpeedKts) const;

    template <typename T>
    void tie(SGPropertyNode* aNode, const char* aRelPath, const SGRawValue<T>& aRawValue)
    {
        _tiedProperties.Tie(aNode->getNode(aRelPath, true), aRawValue);
    }

    void tieSGGeod(SGPropertyNode* aNode, SGGeod& aRef,
                   const char* lonStr, const char* latStr, const char* altStr);

    void tieSGGeodReadOnly(SGPropertyNode* aNode, SGGeod& aRef,
                           const char* lonStr, const char* latStr, const char* altStr);
 
    void updateCurrentWpNode(const SGGeod& p);
    
// FlightPlan::Delegate
    void currentWaypointChanged() override;
    void waypointsChanged() override;
    void cleared() override;
    void endOfFlightPlan() override;
    
    void doSequence();
    void routeManagerFlightPlanChanged(SGPropertyNode*);
    void routeActivated(SGPropertyNode*);
 
// members
    SGPropertyNode_ptr _gpsNode;
    SGPropertyNode_ptr _currentWayptNode;
    SGPropertyNode_ptr _currentWpLatNode,
        _currentWpLonNode, _currentWpAltNode;
    
    SGPropertyNode_ptr _magvar_node;
    SGPropertyNode_ptr _serviceable_node;
    SGPropertyNode_ptr _electrical_node;
    SGPropertyNode_ptr _tracking_bug_node;
    SGPropertyNode_ptr _raim_node;
 
    SGPropertyNode_ptr _odometer_node;
    SGPropertyNode_ptr _trip_odometer_node;
    SGPropertyNode_ptr _true_bug_error_node;
    SGPropertyNode_ptr _magnetic_bug_error_node;
    SGPropertyNode_ptr _eastWestVelocity;
    SGPropertyNode_ptr _northSouthVelocity;
 
    //  SGPropertyNode_ptr _route_active_node;
    SGPropertyNode_ptr _route_current_wp_node;
    SGPropertyNode_ptr _routeDistanceNm;
    SGPropertyNode_ptr _routeETE;
    SGPropertyNode_ptr _desiredCourseNode;
 
    double _selectedCourse;
    double _desiredCourse;
 
    bool _dataValid;
    SGGeod _last_pos;
    bool _lastPosValid;
    double _last_speed_kts;
    double _last_true_track;
    double _last_vertical_speed;
    double _lastEWVelocity;
    double _lastNSVelocity;

    bool _defaultGPSMode;
 
    std::string _mode;
    Config _config;
    std::string _name;
    int _num;
 
    SGGeod _wp0_position;
    SGGeod _indicated_pos;
    double _legDistanceNm;
 
    // scratch data
    SGGeod _scratchPos;
    SGPropertyNode_ptr _scratchNode;
    bool _scratchValid;
#if FG_210_COMPAT
    // search data
    int _searchResultIndex;
    std::string _searchQuery;
    FGPositioned::Type _searchType;
    bool _searchExact;
    FGPositionedList _searchResults;
    bool _searchIsRoute; 
    bool _searchHasNext; 
    bool _searchNames; 
#endif
 
    std::optional<RNAV::LegData> _wp0Data;
 
    std::unique_ptr<flightgear::WayptController> _wayptController;
 
    flightgear::WayptRef _prevWaypt;
    flightgear::WayptRef _currentWaypt;
 
    // autopilot drive properties
    SGPropertyNode_ptr _apDrivingFlag;
    SGPropertyNode_ptr _apTrueHeading;
 
    simgear::TiedPropertyList _tiedProperties;
 
    flightgear::FlightPlanRef _route;
 
    SGPropertyChangeCallback<GPS> _callbackFlightPlanChanged;
    SGPropertyChangeCallback<GPS> _callbackRouteActivated;
};