UBXPlan.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <chrono>
#include <cstdint>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include "GPSReceiverConfig.h"
#include "UBX/UBXConfigKeys.h"
#include "UBX/UBXFrame.h"
#include "UBX/UBXMessageSchema.h"
 
namespace UBX {
enum class Board : uint8_t
{
    unknown = 0,
    u_blox5 = 5,
    u_blox6 = 6,
    u_blox7 = 7,
    u_blox8 = 8,
    u_blox9 = 9,
    u_blox9_F9P_L1L2 = 10,
    u_blox10 = 11,
    u_blox9_F9P_L1L5 = 12,
    u_blox10_L1L5 = 13,
    u_blox_X20 = 14
};
 
struct ReceiverProfile
{
    Board board = Board::unknown;
    std::string_view hardwareVersion{};
    bool rtcmOutput = false;
    bool baseCapabilityKnown = false;
    bool l5HealthOverride = false;
    uint16_t measurementPeriodMs = 100;
    bool protocol27 = false;
};
 
inline constexpr std::array RECEIVER_PROFILES = {
    ReceiverProfile{},
    // Generations before u-blox 8 cannot output RTCM, so they are never configured as a base.
    ReceiverProfile{.board = Board::u_blox5, .hardwareVersion = "00040005", .baseCapabilityKnown = true},
    ReceiverProfile{.board = Board::u_blox6, .hardwareVersion = "00040007", .baseCapabilityKnown = true},
    ReceiverProfile{.board = Board::u_blox7, .hardwareVersion = "00070000", .baseCapabilityKnown = true},
    ReceiverProfile{.board = Board::u_blox8, .hardwareVersion = "00080000"},
    ReceiverProfile{
        .board = Board::u_blox9, .hardwareVersion = "00190000", .baseCapabilityKnown = true, .protocol27 = true},
    ReceiverProfile{.board = Board::u_blox9_F9P_L1L2,
                    .rtcmOutput = true,
                    .baseCapabilityKnown = true,
                    .measurementPeriodMs = 200,
                    .protocol27 = true},
    ReceiverProfile{
        .board = Board::u_blox10, .hardwareVersion = "000A0000", .baseCapabilityKnown = true, .protocol27 = true},
    ReceiverProfile{.board = Board::u_blox9_F9P_L1L5,
                    .rtcmOutput = true,
                    .baseCapabilityKnown = true,
                    .l5HealthOverride = true,
                    .measurementPeriodMs = 200,
                    .protocol27 = true},
    ReceiverProfile{.board = Board::u_blox10_L1L5, .baseCapabilityKnown = true, .protocol27 = true},
    ReceiverProfile{.board = Board::u_blox_X20,
                    .hardwareVersion = "000B0000",
                    .rtcmOutput = true,
                    .baseCapabilityKnown = true,
                    .l5HealthOverride = true,
                    .protocol27 = true},
};
 
[[nodiscard]] constexpr ReceiverProfile receiverProfile(Board board)
{
    for (const auto& profile : RECEIVER_PROFILES) {
        if (profile.board == board) {
            return profile;
        }
    }
    return RECEIVER_PROFILES.front();
}
 
[[nodiscard]] constexpr Board boardFromHardwareVersion(std::string_view hardwareVersion)
{
    for (const auto& profile : RECEIVER_PROFILES) {
        if (!profile.hardwareVersion.empty() && profile.hardwareVersion == hardwareVersion) {
            return profile.board;
        }
    }
    return Board::unknown;
}
}  // namespace UBX
 
namespace UBX::Plan {
 
inline constexpr std::chrono::milliseconds CONFIG_TIMEOUT{250};
inline constexpr std::chrono::milliseconds LEGACY_REPLY_TIMEOUT{1000};
inline constexpr std::chrono::milliseconds IDENTITY_TIMEOUT{2000};
inline constexpr std::chrono::milliseconds PORT_TIMEOUT{2000};
inline constexpr std::chrono::milliseconds BAUD_PROBE_DRAIN{20};
inline constexpr std::chrono::milliseconds SURVEY_STOP_TIMEOUT{3000};
inline constexpr std::chrono::milliseconds SURVEY_STOP_POLL{100};
inline constexpr std::chrono::microseconds DISABLE_MESSAGE_INTERVAL = std::chrono::seconds(1);
 
inline constexpr std::array BAUD_RATES{38400u, 57600u, 9600u, 115200u, 230400u, 460800u, 921600u};
inline constexpr unsigned BASE_BAUD = 115200;
 
inline constexpr size_t VALSET_CAPACITY = 256;
 
inline constexpr uint8_t NO_OUTPUT = 0;
inline constexpr uint8_t STATIONARY_DYNAMIC_MODEL = 2;
inline constexpr uint8_t SURVEY_SATELLITE_RATE = 10;
inline constexpr uint8_t BASE_SATELLITE_INFO_RATE = 2;
inline constexpr uint8_t SURVEY_STATUS_RATE = 5;
inline constexpr uint16_t BASE_MEASUREMENT_PERIOD_MS = 1000;
 
struct ValsetItem
{
    template <typename T>
    constexpr ValsetItem(CfgKey<T> setting, std::type_identity_t<T> setValue, bool when = true)
        : key(setting.id)
        , value(static_cast<uint32_t>(static_cast<std::make_unsigned_t<T>>(setValue)))
        , included(when)
    {}
 
    constexpr ValsetItem(MsgOutKey output, uint8_t rate, bool when = true)
        : key(output.i2c.id)
        , value(rate)
        , msgOut(true)
        , included(when)
    {}
 
    uint32_t key;
    uint32_t value;
    bool msgOut = false;
    bool included = true;
};
 
enum class NakPolicy : uint8_t
{
    Fail,       
    Tolerate,   
    Warn,       
    WriteOnly,  
};
 
struct ValsetBatch
{
    bool included = true;
    NakPolicy policy = NakPolicy::Fail;
    std::chrono::milliseconds timeout = CONFIG_TIMEOUT;
    const char* warning = nullptr;
    std::vector<ValsetItem> items{};
 
    [[nodiscard]] bool required() const { return policy == NakPolicy::Fail || policy == NakPolicy::WriteOnly; }
};
 
[[nodiscard]] ValsetBatch uart1Protocols();
[[nodiscard]] ValsetBatch uart1Baudrate(uint32_t baudrate);
[[nodiscard]] std::vector<ValsetBatch> portsAndNavigation(const ReceiverProfile& profile);
[[nodiscard]] ValsetBatch jammingDetection();
[[nodiscard]] ValsetBatch interferenceMonitor();
[[nodiscard]] std::vector<ValsetBatch> messageOutput(const ReceiverProfile& profile);
[[nodiscard]] ValsetBatch disableRTCMOutput();
[[nodiscard]] ValsetBatch disableTimeMode();
[[nodiscard]] ValsetBatch surveyIn(const GPSBaseStationConfig::SurveyIn& survey);
[[nodiscard]] ValsetBatch fixedBase(const GPSBaseStationConfig::Fixed& fixed);
[[nodiscard]] ValsetBatch rtcmOutput(bool compactObservations);
 
struct UnexpectedOutput
{
    MessageId message;
    MsgOutKey key;
};
 
inline constexpr std::array<UnexpectedOutput, 3> UNEXPECTED_OUTPUT{{{Msg::RXM_RAWX, Cfg::MSGOUT_UBX_RXM_RAWX},
                                                                    {Msg::RXM_SFRBX, Cfg::MSGOUT_UBX_RXM_SFRBX},
                                                                    {Msg::NAV_TIMEGPS, Cfg::MSGOUT_UBX_NAV_TIMEGPS}}};
 
[[nodiscard]] ValsetBatch disableMessage(MsgOutKey key);
 
struct MessageRate
{
    MessageId message;
    uint8_t rate;
};
 
inline constexpr uint16_t LEGACY_PORT_UART1 = 1;
inline constexpr uint16_t LEGACY_PORT_USB = 3;
 
[[nodiscard]] std::array<uint8_t, 2 * WIRE_SIZE<CfgPrt>> legacyPorts(uint32_t baudrate);
 
inline constexpr CfgRate LEGACY_SURVEY_RATE{.measRate = 200, .navRate = 1, .timeRef = 0};
inline constexpr CfgRate LEGACY_BASE_RATE{.measRate = BASE_MEASUREMENT_PERIOD_MS, .navRate = 1, .timeRef = 0};
inline constexpr CfgNav5 LEGACY_NAVIGATION{.mask = 0x0005, .dynModel = STATIONARY_DYNAMIC_MODEL, .fixMode = 2};
[[nodiscard]] std::array<MessageRate, 5> legacyMessageOutput();
inline constexpr MessageRate LEGACY_SURVEY_STATUS{Msg::NAV_SVIN, SURVEY_STATUS_RATE};
[[nodiscard]] std::array<MessageRate, 10> legacyDisableRTCMOutput();
[[nodiscard]] std::array<MessageRate, 2> legacyBaseStatus();
 
enum class RTCMContent : uint8_t
{
    StationPosition,
    Observations,
    Optional,
};
 
struct RTCMOutput
{
    MessageRate rate;
    RTCMContent content;
};
 
[[nodiscard]] std::array<RTCMOutput, 6> legacyRTCMOutput(bool compactObservations);
[[nodiscard]] CfgTmode3 legacySurveyIn(const GPSBaseStationConfig::SurveyIn& survey);
[[nodiscard]] CfgTmode3 legacyFixedBase(const GPSBaseStationConfig::Fixed& fixed);
 
}  // namespace UBX::Plan