GPSReceiver.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
 
#include <QtCore/QHash>
#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtCore/QString>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "GPSObservation.h"
#include "GPSReceiverConnector.h"
#include "GPSReceiverDescriptor.h"
#include "GPSReceiverReports.h"
#include "ScheduledTask.h"
 
class GPSCorrectionManager;
class GPSReceiverConnectionPolicy;
class GPSReceiverFactGroup;
class GPSReceiverSession;
class GPSSourceHealth;
class PositionManager;
class RuntimeScheduler;
class SerialPortManager;
 
struct GPSReceiverDependencies
{
    GPSCorrectionManager* corrections = nullptr;
    PositionManager* positions = nullptr;
#ifndef QGC_NO_SERIAL_LINK
    SerialPortManager* serialPorts = nullptr;
#endif
};
 
struct GPSSerialPortEntry
{
    Q_GADGET
    QML_VALUE_TYPE(gpsSerialPortEntry)
    QML_STRUCTURED_VALUE
    Q_PROPERTY(QString value MEMBER value FINAL)
    Q_PROPERTY(QString label MEMBER label FINAL)
 
public:
    QString value;
    QString label;
 
    bool operator==(const GPSSerialPortEntry&) const = default;
};
 
class GPSReceiver : public QObject, private GPSReceiverConnector
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("Managed by GPSManager")
    Q_MOC_INCLUDE("GPSReceiverFactGroup.h")
 
    Q_PROPERTY(GPSReceiverFactGroup* facts READ facts CONSTANT FINAL)
    Q_PROPERTY(QList<GPSSerialPortEntry> serialPortEntries READ serialPortEntries NOTIFY serialPortEntriesChanged FINAL)
    Q_PROPERTY(QList<int> serialBaudRates READ serialBaudRates CONSTANT FINAL)
    Q_PROPERTY(bool hasReceiver READ hasReceiver NOTIFY receiverChanged FINAL)
    Q_PROPERTY(bool serialSupported READ serialSupported CONSTANT FINAL)
    Q_PROPERTY(QString errorMessage READ errorMessage NOTIFY errorMessageChanged FINAL)
    Q_PROPERTY(int activeBaseMode READ activeBaseMode NOTIFY receiverChanged FINAL)
    Q_PROPERTY(QString activeEndpoint READ activeEndpoint NOTIFY receiverChanged FINAL)
    Q_PROPERTY(QString receiverIdentity READ receiverIdentity NOTIFY receiverChanged FINAL)
    Q_PROPERTY(QString detectedReceiver READ detectedReceiver NOTIFY receiverChanged FINAL)
    Q_PROPERTY(bool reconnecting READ reconnecting NOTIFY receiverChanged FINAL)
    Q_PROPERTY(GPSReceiverPresentation activePresentation READ activePresentation NOTIFY receiverChanged FINAL)
    Q_PROPERTY(RTKSettings::ReceiverRole activeRole READ activeRole NOTIFY receiverChanged FINAL)
    Q_PROPERTY(bool forwardingCorrections READ forwardingCorrections NOTIFY receiverChanged FINAL)
    Q_PROPERTY(bool persistentChangesAllowed READ persistentChangesAllowed WRITE setPersistentChangesAllowed NOTIFY
                   persistentChangesAllowedChanged FINAL)
    Q_PROPERTY(RTKSettings::ConnectionType effectiveConnectionType READ effectiveConnectionType NOTIFY
                   configurationChanged FINAL)
    Q_PROPERTY(bool connectionSupported READ connectionSupported NOTIFY configurationChanged FINAL)
    Q_PROPERTY(QString summaryLabel READ summaryLabel NOTIFY summaryLabelChanged FINAL)
    Q_PROPERTY(QString statusText READ statusText NOTIFY statusTextChanged FINAL)
    Q_PROPERTY(bool baseModeSupported READ baseModeSupported NOTIFY configurationChanged FINAL)
    Q_PROPERTY(bool canConnect READ canConnect NOTIFY configurationChanged FINAL)
 
    friend class GPSReceiverTest;
    friend class GPSReceiverSettingsBindingTest;
    friend class GPSReceiverConnectionPolicyTest;
 
public:
    using Configuration = GPSReceiverConfiguration;
    using WorkerFactory = GPSReceiverWorkerFactory;
 
    static constexpr std::chrono::seconds POLL_INTERVAL{1};
    static constexpr std::chrono::seconds OUTPUT_OVERFLOW_WARNING_DURATION{30};
    static constexpr std::chrono::seconds SHUTDOWN_TIMEOUT{2};
 
    using Dependencies = GPSReceiverDependencies;
 
    explicit GPSReceiver(QObject* parent = nullptr, RuntimeScheduler* scheduler = nullptr,
                         const Dependencies& dependencies = {});
    ~GPSReceiver();
 
    void setConfiguration(const Configuration& configuration);
    void setWorkerFactory(WorkerFactory factory);
 
    const Configuration& configuration() const { return _configuration; }
 
    QList<GPSSerialPortEntry> serialPortEntries() const { return _serialPortEntries; }
 
    static QList<int> serialBaudRates();
 
    std::optional<GPSObservation> acceptedPositionObservation(GPSObservation::PositionUse use) const;
    Q_INVOKABLE bool connectReceiver();
    Q_INVOKABLE void disconnectReceiver();
    void startConnectionPolling(std::function<bool()> suspended = {});
    void tick();
    void shutdown();
 
    GPSReceiverFactGroup* facts() const { return _facts; }
 
    bool hasReceiver() const override;
 
    bool serialSupported() const
    {
#ifdef QGC_NO_SERIAL_LINK
        return false;
#else
        return true;
#endif
    }
 
    QString errorMessage() const;
 
    int activeBaseMode() const;
 
    QString activeEndpoint() const;
 
    QString receiverIdentity() const;
 
    QString detectedReceiver() const;
 
    QString summaryLabel() const { return _summaryLabel; }
 
    QString statusText() const { return _statusText; }
 
    bool reconnecting() const;
 
    Q_INVOKABLE GPSReceiverPresentation capabilitiesFor(int role, int manufacturer) const;
 
    GPSReceiverPresentation activePresentation() const;
 
    RTKSettings::ReceiverRole activeRole() const;
 
    bool forwardingCorrections() const;
 
    bool persistentChangesAllowed() const { return _persistentChangesAllowed; }
 
    void setPersistentChangesAllowed(bool allowed);
 
    RTKSettings::ConnectionType effectiveConnectionType() const { return _configuration.effectiveConnectionType(); }
 
    bool connectionSupported() const;
 
    bool baseModeSupported() const;
 
    bool canConnect() const;
 
signals:
    void receiverChanged();
    void errorMessageChanged();
    void configurationChanged();
    void persistentChangesAllowedChanged();
    void serialPortEntriesChanged();
    void summaryLabelChanged();
    void statusTextChanged();
 
private slots:
    void _onSatelliteInfoUpdated(const GPSSatelliteReport& msg);
    void _onPositionUpdated(const GPSPositionReport& report);
    void _onGPSConnect();
    void _onReceiverDetected();
    void _onInputProblem(GPSInputProblem problem);
    void _onGPSSurveyReport(const GPSSurveyReport& status);
 
private:
    struct ReceiverState
    {
        bool hasReceiver = false;
        int baseMode = -1;
        QString endpoint;
        QString identity;
        QString detected;
        bool reconnecting = false;
        GPSReceiverPresentation presentation;
        RTKSettings::ReceiverRole role = RTKSettings::ConfiguredBase;
        bool forwardingCorrections = false;
        bool operator==(const ReceiverState&) const = default;
    };
 
    struct Notified
    {
        quint64 configurationRevision = 0;
        bool persistentChangesAllowed = false;
        QString errorMessage;
        ReceiverState receiver;
    };
 
    int _activeManufacturer() const;
 
    void setConnectionError(const QString& message) override { _setError(message); }
 
    void endConnection(bool clearError) override;
    bool connectTcp(const QString& host, quint16 port, GPSType type, bool allowPersistentChanges) override;
    bool connectUdp(quint16 port, GPSType type) override;
#ifndef QGC_NO_SERIAL_LINK
    bool connectSerial(const QString& device, GPSType type, uint32_t baudRate, bool allowPersistentChanges,
                       GPSSerialClaim claim) override;
    bool serialPortAvailable(const QString& device) const override;
    QStringList rtkReceiverPorts() const override;
    GPSSerialClaim claimSerialPort(const QString& device) override;
    void _onSerialPortsEnumerated(const QStringList& devices);
    void _updateSerialPortEntries();
#endif
 
    bool _connectReceiver(GPSType type, GPSReceiverWorker::TransportFactory transportFactory,
                          const QString& sourceInstance, uint32_t baudRate, bool allowPersistentChanges,
                          const QString& serialDevice = {}, const QString& endpoint = {});
    void _endSession(GPSConnectionError error, const QString& detail, bool portRemoved);
    void _retireSession();
    void _joinRetiredWorkers();
 
    void _setError(const QString& message = {}) { _errorMessage = message; }
 
    void _updateOutputOverflow(uint64_t receiptUs);
    void _setPersistentChangesAllowed(bool allowed);
    void _resetStatus();
    void _updateLabels();
    void _clearStaleSolution();
    ReceiverState _receiverState() const;
    void _emitChanges();
 
    Configuration _configuration;
    GPSReceiverSession* _session = nullptr;
    QList<QPointer<GPSReceiverWorker>> _retiredWorkers;
    const QPointer<GPSCorrectionManager> _correctionManager;
    const QPointer<PositionManager> _positionManager;
    RuntimeScheduler* const _scheduler;
    GPSSourceHealth* const _positionHealth;
    ScheduledTask _outputOverflowTask;
    ScheduledTask _pollTask;
    quint64 _sessionCount = 0;
    QString _errorMessage;
    QString _summaryLabel;
    QString _statusText;
    QString _outputOverflowWarning;
    uint64_t _outputOverflowUs = 0;
    std::unique_ptr<GPSReceiverConnectionPolicy> _connection;
    GPSReceiverFactGroup* _facts = nullptr;
    WorkerFactory _workerFactory;
    quint64 _configurationRevision = 0;
    Notified _notified;
    bool _destroying = false;
    bool _persistentChangesAllowed = false;
    QList<GPSSerialPortEntry> _serialPortEntries;
#ifndef QGC_NO_SERIAL_LINK
    const QPointer<SerialPortManager> _serialPorts;
    QHash<QString, std::weak_ptr<const SerialPortManager::Reservation>> _serialClaims;
    std::function<std::unique_ptr<GPSTransport>(const QString&, GPSCancelToken)> _serialTransportFactory;
#endif
};