GPSCorrectionManager.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <optional>
 
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "DataRateTracker.h"
#include "GPSCorrectionSelector.h"
#include "RTCMMAVLink.h"
#include "RTCMUdpInput.h"
#include "ScheduledTask.h"
#include "UdpForwarder.h"
 
class GPSCorrectionManager;
class RuntimeScheduler;
 
class GPSCorrectionSourceHandle
{
public:
    ~GPSCorrectionSourceHandle();
    Q_DISABLE_COPY_MOVE(GPSCorrectionSourceHandle)
 
    
    void submit(const QByteArray& data, qint64 receivedAtMs, const QString& instance = {}) const;
 
private:
    friend class GPSCorrectionManager;
    GPSCorrectionSourceHandle(GPSCorrectionManager* manager, GPSCorrectionSettings::CorrectionSource source,
                              const QString& instance);
 
    const QPointer<GPSCorrectionManager> _manager;
    const GPSCorrectionSettings::CorrectionSource _source;
    const QString _instance;
};
 
class GPSCorrectionManager : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_UNCREATABLE("Provided by the GPS manager")
    Q_PROPERTY(State state READ state NOTIFY stateChanged FINAL)
    Q_PROPERTY(GPSCorrectionStream selectedStream READ selectedStream NOTIFY stateChanged FINAL)
    Q_PROPERTY(quint64 selectedBytesPerSecond READ selectedBytesPerSecond NOTIFY selectedBytesPerSecondChanged FINAL)
    Q_PROPERTY(quint64 vehicleBytesSubmitted READ vehicleBytesSubmitted NOTIFY vehicleBytesSubmittedChanged FINAL)
    Q_PROPERTY(QString udpInputError READ udpInputError NOTIFY udpInputChanged FINAL)
    Q_PROPERTY(QString udpOutputError READ udpOutputError NOTIFY udpOutputChanged FINAL)
 
    friend class GPSCorrectionSourceHandle;
 
public:
    enum class State
    {
        Inactive,
        Waiting,
        Fresh,
    };
    Q_ENUM(State)
 
    struct UdpInputConfiguration
    {
        bool enabled = false;
        quint16 port = 0;
        bool operator==(const UdpInputConfiguration&) const = default;
    };
 
    struct UdpOutputConfiguration
    {
        bool enabled = false;
        QString address{};
        quint16 port = 0;
        bool operator==(const UdpOutputConfiguration&) const = default;
    };
 
    struct Configuration
    {
        GPSCorrectionSettings::CorrectionSource source = GPSCorrectionSettings::HighestPriority;
        UdpInputConfiguration udpInput;
        UdpOutputConfiguration udpOutput;
        bool operator==(const Configuration&) const = default;
    };
 
    explicit GPSCorrectionManager(QObject* parent = nullptr, RuntimeScheduler* scheduler = nullptr);
    ~GPSCorrectionManager() override;
 
    void shutdown();
 
    RTCMMAVLink* rtcmMavlink() { return &_rtcmMavlink; }
 
    void setConfiguration(const Configuration& configuration);
    [[nodiscard]] std::unique_ptr<GPSCorrectionSourceHandle> openSource(GPSCorrectionSettings::CorrectionSource source,
                                                                        const QString& instance);
 
    State state() const { return _state; }
 
    GPSCorrectionStream selectedStream() const { return _selected; }
 
    quint64 selectedBytesPerSecond() const { return _selectedBytesPerSecond; }
 
    quint64 vehicleBytesSubmitted() const { return _rtcmMavlink.totalBytesSubmitted(); }
 
    QString udpInputError() const { return _udpInputError; }
 
    QString udpOutputError() const { return _udpOutputError; }
 
    Q_INVOKABLE static QString sourceName(int source);
 
signals:
    void stateChanged();
    void selectedBytesPerSecondChanged();
    void vehicleBytesSubmittedChanged();
    void udpInputChanged();
    void udpOutputChanged();
 
private:
    void _beginSource(GPSCorrectionSettings::CorrectionSource source);
    void _endSource(GPSCorrectionSettings::CorrectionSource source);
    void _submit(GPSCorrectionSettings::CorrectionSource source, const QString& instance, const QByteArray& data,
                 qint64 receivedAtMs);
 
    [[nodiscard]] bool _applyUdpInput();
    [[nodiscard]] bool _applyUdpOutput();
    bool _udpInputEnabled() const;
    void _startUdpInput();
    void _retryUdpInput();
 
    void _scheduleRefresh();
    void _refresh();
 
    RuntimeScheduler* const _scheduler;
    ScheduledTask _refreshTask;
    ScheduledTask _tickTask;
    GPSCorrectionSelector _selector;
    DataRateTracker _selectedRate;
    RTCMMAVLink _rtcmMavlink;
    RTCMUdpInput _udpInput;
    std::unique_ptr<GPSCorrectionSourceHandle> _udpSource;
    UdpForwarder _udpOutput{this};
    std::optional<Configuration> _configuration;
    State _state = State::Inactive;
    GPSCorrectionStream _selected;
    quint64 _selectedBytesPerSecond = 0;
    QString _udpInputError;
    QString _udpOutputError;
    bool _shutdown = false;
};