GPSProtocolEvent.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <variant>
#include <vector>
 
#include <QtCore/QByteArray>
#include <QtCore/QFlags>
 
#include "GPSReceiverReports.h"
#include "GPSType.h"
 
enum class GPSReceiveUpdate : uint8_t
{
    Position = 0x1,
    Satellites = 0x2,
    Activity = 0x4,
};
Q_DECLARE_FLAGS(GPSReceiveUpdates, GPSReceiveUpdate)
Q_DECLARE_OPERATORS_FOR_FLAGS(GPSReceiveUpdates)
 
 
struct GPSDecodedPosition
{
    GPSNavigationValues navigation{};
    bool velocityValid{};
};
 
struct GPSDecodedSatellites
{
    static constexpr uint16_t SAT_INFO_MAX_SATELLITES = 128;
    static constexpr uint8_t MAX_CONSTELLATIONS = 8;
 
    struct Constellation
    {
        GPSConstellation constellation = GPSConstellation::Unknown;
        uint64_t inViewTimestampUs = 0;
        int inView = 0;
        uint64_t inUseTimestampUs = 0;
        std::optional<int> inUse = std::nullopt;
    };
 
    Constellation* ensureConstellation(GPSConstellation constellation)
    {
        for (uint8_t index = 0; index < count; ++index) {
            if (constellations[index].constellation == constellation) {
                return &constellations[index];
            }
        }
        if (count >= constellations.size()) {
            return nullptr;
        }
        auto& report = constellations[count++];
        report.constellation = constellation;
        return &report;
    }
 
    void addSatellite(GPSConstellation constellation, bool used)
    {
        if (auto* system = ensureConstellation(constellation)) {
            ++system->inView;
            system->inUse = system->inUse.value_or(0) + (used ? 1 : 0);
        }
    }
 
    // Full snapshots retire omitted constellations; deltas preserve them.
    bool fullSnapshot = true;
    uint8_t count = 0;
    std::array<Constellation, MAX_CONSTELLATIONS> constellations{};
};
 
struct GPSDecodedSatelliteUsage
{
    uint64_t timestampUs = 0;
    std::optional<int> usedCount = std::nullopt;
};
 
[[nodiscard]] inline std::optional<uint8_t> gpsSatellitesUsed(std::optional<unsigned> count)
{
    return count && *count < UINT8_MAX ? std::optional<uint8_t>(static_cast<uint8_t>(*count)) : std::nullopt;
}
 
struct GPSRTCMFrame
{
    QByteArray bytes{};
};
 
struct GPSInputProtocol
{
    GPSType family = GPSType::passive;
};
 
using GPSProtocolEvent = std::variant<GPSDecodedPosition, GPSIntegrityReport, GPSDecodedSatellites,
                                      GPSDecodedSatelliteUsage, GPSSurveyReport, GPSRTCMFrame, GPSInputProtocol>;
 
struct GPSEventBatch
{
    std::vector<GPSProtocolEvent> events{};
    GPSReceiveUpdates updates{};
};