GPSReceiverSession.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <optional>
#include <utility>
 
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtCore/QString>
 
#include "GPSObservation.h"
#include "GPSReceiverConfig.h"
#include "GPSReceiverConnector.h"
#include "GPSReceiverReports.h"
#include "GPSReceiverWorker.h"
#include "PositionManager.h"
 
class GPSCorrectionManager;
class GPSCorrectionSourceHandle;
class GPSSourceHealth;
 
struct GPSBaseStationState
{
    std::optional<BaseModeDefinition::Mode> mode;
    std::optional<std::pair<GPSEllipsoidPosition, double>> position;
    std::optional<double> surveyAccuracyLimitMeters;
 
    void applySurvey(const GPSSurveyReport& report);
};
 
[[nodiscard]] GPSReceiverConfig gpsReceiverConfigFor(const GPSBaseStationConfig& base, GPSType type, uint32_t baudRate,
                                                     bool allowPersistentChanges, QString* error);
 
[[nodiscard]] GPSBaseStationState gpsBaseStationStateFor(GPSType type, const GPSReceiverConfig& config);
 
class GPSReceiverSession : public QObject
{
    Q_OBJECT
 
public:
    struct Connection
    {
        GPSType type = GPSType::ublox;
        RTKSettings::ReceiverRole role = RTKSettings::ConfiguredBase;
        bool forwardsCorrections = true;
        GPSReceiverConfig config{};
        QString serialDevice;
        QString endpoint;
    };
 
    GPSReceiverSession(quint64 id, Connection connection, QObject* parent);
    ~GPSReceiverSession() override;
 
    void registerCorrections(GPSCorrectionManager* manager, const QString& sourceInstance);
    bool start(const GPSReceiverWorkerFactory& factory, GPSReceiverWorker::TransportFactory transportFactory);
    void registerPosition(PositionManager* positionManager, GPSSourceHealth* producer);
    void retire();
 
    bool hasWorker() const { return !_worker.isNull(); }
 
    QPointer<GPSReceiverWorker> worker() const { return _worker; }
 
    RTKSettings::ReceiverRole role() const { return _connection.role; }
 
    bool forwardsCorrections() const { return _connection.forwardsCorrections; }
 
    bool compactObservations() const { return _connection.config.base.compactObservations; }
 
    int manufacturer() const
    {
        return gpsReceiverManufacturerForType(
            _connection.type == GPSType::automatic ? _detectedType.value_or(GPSType::automatic) : _connection.type);
    }
 
    std::optional<GPSType> detectedType() const { return _detectedType; }
 
    int baseMode() const { return _base.mode ? static_cast<int>(*_base.mode) : -1; }
 
    const QString& serialDevice() const { return _connection.serialDevice; }
 
    const QString& endpoint() const { return _connection.endpoint; }
 
    const QString& identity() const { return _identity; }
 
    GPSObservation observation(const GPSPositionReport& report, quint64 receivedAtUs) const;
 
signals:
    void satelliteInfoUpdated(const GPSSatelliteReport& report);
    void positionUpdated(const GPSPositionReport& report);
    void surveyInStatusUpdated(const GPSSurveyReport& report);
    void receiverReady(const QString& identity);
    void receiverDetected(GPSType type);
    void inputProblem(GPSInputProblem problem);
    void ended(GPSConnectionError error, const QString& detail);
 
private:
    void _onSurvey(const GPSSurveyReport& report);
    void _onReady(const QString& identity);
    void _onDetected(GPSType type);
    void _forwardCorrection(const QByteArray& data, qint64 receivedAtMs);
 
    const quint64 _sessionId;
    const Connection _connection;
    GPSBaseStationState _base;
    QPointer<GPSReceiverWorker> _worker;
    std::unique_ptr<GPSCorrectionSourceHandle> _correction;
    GPSPositionSourceRegistration _position;
    QString _identity;
    std::optional<GPSType> _detectedType;
    bool _retired = false;
};