UBXProtocol.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <vector>
 
#include <QtCore/QByteArray>
#include <QtCore/QString>
 
#include "GPSCommand.h"
#include "GPSFamilyProtocol.h"
#include "GPSProtocolEvent.h"
#include "GPSReceiverConfig.h"
#include "GPSStreamDemux.h"
#include "UBX/UBXConfigKeys.h"
#include "UBX/UBXEpochAssembler.h"
#include "UBX/UBXFrame.h"
#include "UBX/UBXPlan.h"
#include "UBX/UBXReceiverController.h"
 
class GPSCommandChannel;
class GPSDecodeContext;
class GPSStreamDemux;
 
namespace UBX {
 
struct Identity
{
    Board board = Board::unknown;
    bool isM8p = false;
    bool protocol27 = false;
    bool timeModeUnsupported = false;
    QByteArray hardware;
    QByteArray protocolVersion;
    QByteArray model;
    QByteArray firmware;
};
 
class Protocol final : public GPSFamilyProtocol
{
public:
    static constexpr std::array NAVIGATION_MESSAGES{Msg::NAV_PVT,    Msg::NAV_HPPOSLLH, Msg::NAV_DOP,
                                                    Msg::NAV_STATUS, Msg::MON_HW,       Msg::MON_RF,
                                                    Msg::SEC_SIG,    Msg::NAV_SAT,      Msg::NAV_SVINFO};
 
    static constexpr std::chrono::seconds REPEATED_WARNING_INTERVAL{60};
 
    bool configure(GPSCommandChannel& channel, GPSConfig config, unsigned& baud) override;
 
    bool probe(GPSCommandChannel& channel) override;
 
    GPSReceiveUpdates onFrame(const GPSFrame& frame, GPSDecodeContext& context) override;
 
    void flush(GPSDecodeContext& context) override;
 
    bool receiverReady() const override { return _ready; }
 
    QString identity() const override { return gpsReceiverIdentity(_identity.model, _identity.firmware); }
 
    bool armDecodeOnly(const GPSConfig& config, GPSDecodeContext& context) override;
 
    bool armNavigationDecode(GPSNavigationDecode decode, GPSDecodeContext& context) override;
 
    bool completeReceiveCycle(GPSReceiveUpdates handled) override;
 
    [[nodiscard]] std::chrono::milliseconds nextReadSlice(std::chrono::milliseconds timeout) const override;
 
    void serviceStreaming(GPSCommandChannel& channel) override;
 
private:
    struct Mode
    {
        bool navigation = false;
        bool corrections = false;
    };
 
    struct Requests
    {
        bool rtcmActivation = false;
        uint16_t disableMessage = 0;
    };
 
    enum class RTCMActivation : uint8_t
    {
        Active,
        Failed,
        Unanswered,
    };
 
    struct RateConfirmation
    {
        GPSCommandOutcome outcome;
        bool settled;
    };
 
    struct LegacyRTCMProgress
    {
        size_t next = 0;
        bool stationPosition = false;
        bool observations = false;
    };
 
    // Decoding (UBXDecoder.cc)
 
    void _setMode(const Mode& mode, GPSStreamDemux& stream);
    GPSReceiveUpdates _decode(uint16_t message, std::span<const uint8_t> payload, GPSDecodeContext& context);
    // The decoders below receive payloads that _decode() validated against their message schema.
    bool _accept(uint16_t message, std::span<const uint8_t> payload);
    void _decodeEpoch(uint16_t message, std::span<const uint8_t> payload, EpochAssembler::Epoch& epoch);
    GPSReceiveUpdates _decodeHandled(uint16_t message, std::span<const uint8_t> payload, GPSDecodeContext& context);
    GPSReceiveUpdates _decodeSurveyIn(std::span<const uint8_t> payload, GPSDecodeContext& context);
    void _decodeMonVer(std::span<const uint8_t> payload);
    void _decodeSatellites(uint16_t message, std::span<const uint8_t> payload);
 
    // Configuration and streaming services (UBXConfigurator.cc)
 
    [[nodiscard]] bool _baseStationUnsupported() const;
    bool _identify(GPSCommandChannel& channel);
    bool _setUpPort(GPSCommandChannel& channel, unsigned detectedBaud, unsigned desiredBaud);
    bool _configureDevice(GPSCommandChannel& channel);
    bool _configureJammingDetection(GPSCommandChannel& channel);
    bool _configureLegacyDevice(GPSCommandChannel& channel);
    bool _restartSurveyIn(GPSCommandChannel& channel);
    bool _restartLegacySurveyIn(GPSCommandChannel& channel);
    bool _disableTimeMode(GPSCommandChannel& channel);
    bool _waitForSurveyStop(GPSCommandChannel& channel);
    RTCMActivation _activateRTCMOutput(GPSCommandChannel& channel);
    RTCMActivation _activateLegacyRTCMOutput(GPSCommandChannel& channel);
    void _disableUnexpectedMessage(GPSCommandChannel& channel, uint16_t message);
 
    bool _send(GPSCommandChannel& channel, MessageId message, std::span<const uint8_t> payload,
               GPSConfigurationStep step);
    bool _sendAcknowledged(GPSCommandChannel& channel, MessageId message, std::span<const uint8_t> payload);
    GPSConfigurationEvidence _waitForAck(GPSCommandChannel& channel, MessageId message);
    bool _setMessageRate(GPSCommandChannel& channel, Plan::MessageRate rate);
    bool _setMessageRateAcknowledged(GPSCommandChannel& channel, Plan::MessageRate rate);
    GPSCommandOutcome _setMessageRateReply(GPSCommandChannel& channel, Plan::MessageRate rate);
    RateConfirmation _confirmMessageRate(GPSCommandChannel& channel, Plan::MessageRate rate);
    bool _runPlan(GPSCommandChannel& channel, const std::vector<Plan::ValsetBatch>& batches);
    [[nodiscard]] bool _valsetsRefused() const;
    void _load(const Plan::ValsetBatch& batch);
    bool _writeValset(GPSCommandChannel& channel, const Plan::ValsetBatch& batch);
    GPSConfigurationEvidence _transactValset(GPSCommandChannel& channel, const Plan::ValsetBatch& batch);
    GPSConfigurationEvidence _awaitValsetAck(GPSCommandChannel& channel);
    GPSConfigurationEvidence _verifyValset(GPSCommandChannel& channel, GPSConfigurationStep step);
 
    // What configuration and the streaming services share with decoding.
    Identity _identity{};
    ReceiverController _controller{};
    Mode _mode{};
    Requests _requests{};
    bool _timeModeReadbackPending = false;
    std::optional<uint8_t> _timeModeReadback = std::nullopt;
    bool _surveyStopped = false;
    bool _ready = false;
    bool _secSigSeen = false;
 
    // Decoding
    EpochAssembler _epochs;
    GPSDecodedSatellites _satellites;
    GPSIntegrityReport _integrity;
    bool _epochStarted = false;
    QString _lastWarning;
    uint64_t _lastWarningUs = 0;
 
    // Configuration
    GPSBaseStationConfig _base;
    CheckedValsetBatch<Plan::VALSET_CAPACITY> _valset;
    bool _valsetAckAmbiguous = false;
    LegacyRTCMProgress _legacyRTCM;
    uint64_t _lastDisableUs = 0;
};
 
}  // namespace UBX