UbloxTypes.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <string>
#include <array>
#include <optional>
#include <bitset>
#include <vector>
#include <cstdint>
#include <fmt/ostream.h>
 
#include "Navigation/GNSS/Core/SatelliteIdentifier.hpp"
 
namespace NAV::vendor::ublox
{
enum ErrorDetectionMode
{
    ERRORDETECTIONMODE_NONE,     
    ERRORDETECTIONMODE_CHECKSUM, 
};
 
enum NmeaTalkerID
{
    NMEA_TALKER_ID_OFF = 0, 
    NMEA_TALKER_ID_GP = 1,  
    NMEA_TALKER_ID_GL = 2,  
    NMEA_TALKER_ID_GA = 3,  
    NMEA_TALKER_ID_GB = 4,  
    NMEA_TALKER_ID_GN = 5   
};
 
enum NmeaMessageClass
{
    NMEA_MSG_CLASS_STANDARD = 0xF0, 
    NMEA_MSG_CLASS_PUBX = 0xF1      
};
 
enum NmeaStandardMessages
{
    NMEA_STANDARD_MSG_DTM = 0x0A, 
    NMEA_STANDARD_MSG_GBQ = 0x44, 
    NMEA_STANDARD_MSG_GBS = 0x09, 
    NMEA_STANDARD_MSG_GGA = 0x00, 
    NMEA_STANDARD_MSG_GLL = 0x01, 
    NMEA_STANDARD_MSG_GLQ = 0x43, 
    NMEA_STANDARD_MSG_GNQ = 0x42, 
    NMEA_STANDARD_MSG_GNS = 0x0D, 
    NMEA_STANDARD_MSG_GPQ = 0x40, 
    NMEA_STANDARD_MSG_GRS = 0x06, 
    NMEA_STANDARD_MSG_GSA = 0x02, 
    NMEA_STANDARD_MSG_GST = 0x07, 
    NMEA_STANDARD_MSG_GSV = 0x03, 
    NMEA_STANDARD_MSG_RMC = 0x04, 
    NMEA_STANDARD_MSG_TXT = 0x41, 
    NMEA_STANDARD_MSG_VLW = 0x0F, 
    NMEA_STANDARD_MSG_VTG = 0x05, 
    NMEA_STANDARD_MSG_ZDA = 0x08  
};
 
enum NmeaPubxMessages
{
    NMEA_PUBX_MSG_CONFIG = 0x41,   
    NMEA_PUBX_MSG_POSITION = 0x00, 
    NMEA_PUBX_MSG_RATE = 0x40,     
    NMEA_PUBX_MSG_SVSTATUS = 0x03, 
    NMEA_PUBX_MSG_TIME = 0x04      
};
 
enum UbxClass
{
    UBX_CLASS_NONE = 0x00,               
    UBX_CLASS_NAV = 0x01,                
    UBX_CLASS_RXM = 0x02,                
    UBX_CLASS_INF = 0x04,                
    UBX_CLASS_ACK = 0x05,                
    UBX_CLASS_CFG = 0x06,                
    UBX_CLASS_UPD = 0x09,                
    UBX_CLASS_MON = 0x0A,                
    UBX_CLASS_AID [[deprecated]] = 0x0B, 
    UBX_CLASS_TIM = 0x0D,                
    UBX_CLASS_ESF = 0x10,                
    UBX_CLASS_MGA = 0x13,                
    UBX_CLASS_LOG = 0x21,                
    UBX_CLASS_SEC = 0x27,                
    UBX_CLASS_HNR = 0x28                 
};
 
enum UbxAckMessages
{
    UBX_ACK_ACK = 0x01,
    UBX_ACK_NAK = 0x00
};
 
struct UbxAckAck
{
    uint8_t clsID = 0; 
    uint8_t msgID = 0; 
};
 
struct UbxAckNak
{
    uint8_t clsID = 0; 
    uint8_t msgID = 0; 
};
 
enum UbxCfgMessages
{
    UBX_CFG_ANT = 0x13,
    UBX_CFG_BATCH = 0x93,
    UBX_CFG_CFG = 0x09,
    UBX_CFG_DAT = 0x06,
    UBX_CFG_DGNSS = 0x70,
    UBX_CFG_DOSC = 0x61,
    UBX_CFG_ESRC = 0x60,
    UBX_CFG_GEOFENCE = 0x69,
    UBX_CFG_GNSS = 0x3E,
    UBX_CFG_HNR = 0x5C,
    UBX_CFG_INF = 0x02,
    UBX_CFG_ITFM = 0x39,
    UBX_CFG_LOGFILTER = 0x47,
    UBX_CFG_MSG = 0x01,
    UBX_CFG_NAV5 = 0x24,
    UBX_CFG_NAVX5 = 0x23,
    UBX_CFG_NMEA = 0x17,
    UBX_CFG_ODO = 0x1E,
    UBX_CFG_PM2 = 0x3B,
    UBX_CFG_PMS = 0x86,
    UBX_CFG_PRT = 0x00,
    UBX_CFG_PWR = 0x57,
    UBX_CFG_RATE = 0x08,
    UBX_CFG_RINV = 0x34,
    UBX_CFG_RST = 0x04,
    UBX_CFG_RXM = 0x11,
    UBX_CFG_SBAS = 0x16,
    UBX_CFG_SLAS = 0x8D,
    UBX_CFG_SMGR = 0x62,
    UBX_CFG_TMODE2 = 0x3D,
    UBX_CFG_TMODE3 = 0x71,
    UBX_CFG_TP5 = 0x31,
    UBX_CFG_TXSLOT = 0x53,
    UBX_CFG_USB = 0x1B,
};
 
enum UbxEsfMessages
{
    UBX_ESF_INS = 0x15,
    UBX_ESF_MEAS = 0x02,
    UBX_ESF_RAW = 0x03,
    UBX_ESF_STATUS = 0x10,
};
 
struct UbxEsfIns
{
    std::bitset<4UL * 8UL> bitfield0;   
    std::array<uint8_t, 4> reserved1{}; 
    uint32_t iTOW = 0;                  
    int32_t xAngRate = 0;               
    int32_t yAngRate = 0;               
    int32_t zAngRate = 0;               
    int32_t xAccel = 0;                 
    int32_t yAccel = 0;                 
    int32_t zAccel = 0;                 
};
 
struct UbxEsfMeas
{
    uint32_t timeTag = 0;                           
    std::bitset<2UL * 8UL> flags;                   
    uint16_t id = 0;                                
    std::vector<uint32_t> data;                     
    std::optional<std::vector<uint32_t>> calibTtag; 
};
 
struct UbxEsfRaw
{
    struct UbxEsfRawData
    {
        uint32_t data = 0;  
        uint32_t sTtag = 0; 
    };
 
    std::array<uint8_t, 4> reserved1{}; 
    std::vector<UbxEsfRawData> data;    
};
 
struct UbxEsfStatus
{
    struct UbxEsfStatusSensor
    {
        std::bitset<1UL * 8UL> sensStatus1; 
        std::bitset<1UL * 8UL> sensStatus2; 
        uint8_t freq = 0;                   
        std::bitset<1UL * 8UL> faults;      
    };
 
    uint32_t iTOW = 0;                  
    uint8_t version = 0;                
    std::array<uint8_t, 7> reserved1{}; 
    uint8_t fusionMode = 0;
    std::array<uint8_t, 2> reserved2{};      
    uint8_t numSens = 0;                     
    std::vector<UbxEsfStatusSensor> sensors; 
};
 
enum UbxHnrMessages
{
    UBX_HNR_INS = 0x02,
    UBX_HNR_PVT = 0x00,
};
 
enum UbxInfMessages
{
    UBX_INF_DEBUG = 0x04,
    UBX_INF_ERROR = 0x00,
    UBX_INF_NOTICE = 0x02,
    UBX_INF_TEST = 0x03,
    UBX_INF_WARNING = 0x01,
};
 
enum UbxLogMessages
{
    UBX_LOG_BATCH = 0x11,
    UBX_LOG_CREATE = 0x07,
    UBX_LOG_ERASE = 0x03,
    UBX_LOG_FINDTIME = 0x0E,
    UBX_LOG_INFO = 0x08,
    UBX_LOG_RETRIEVEBATCH = 0x10,
    UBX_LOG_RETRIEVEPOSEXTRA = 0x0F,
    UBX_LOG_RETRIEVEPOS = 0x0B,
    UBX_LOG_RETRIEVESTRING = 0x0D,
    UBX_LOG_RETRIEVE = 0x09,
    UBX_LOG_STRING = 0x04,
};
 
enum UbxMgaMessages
{
    UBX_MGA_ACK_DATA0 = 0x60,
    UBX_MGA_ANO = 0x20,
    UBX_MGA_BDS_EPH = 0x03,
    UBX_MGA_BDS_ALM = 0x03,
    UBX_MGA_BDS_HEALTH = 0x03,
    UBX_MGA_BDS_UTC = 0x03,
    UBX_MGA_BDS_IONO = 0x03,
    UBX_MGA_DBD = 0x80,
    UBX_MGA_FLASH_DATA = 0x21,
    UBX_MGA_FLASH_STOP = 0x21,
    UBX_MGA_FLASH_ACK = 0x21,
    UBX_MGA_GAL_EPH = 0x02,
    UBX_MGA_GAL_ALM = 0x02,
    UBX_MGA_GAL_TIMEOFFSET = 0x02,
    UBX_MGA_GAL_UTC = 0x02,
    UBX_MGA_GLO_EPH = 0x06,
    UBX_MGA_GLO_ALM = 0x06,
    UBX_MGA_GLO_TIMEOFFSET = 0x06,
    UBX_MGA_GPS_EPH = 0x00,
    UBX_MGA_GPS_ALM = 0x00,
    UBX_MGA_GPS_HEALTH = 0x00,
    UBX_MGA_GPS_UTC = 0x00,
    UBX_MGA_GPS_IONO = 0x00,
    UBX_MGA_INI_POS_XYZ = 0x40,
    UBX_MGA_INI_POS_LLH = 0x40,
    UBX_MGA_INI_TIME_UTC = 0x40,
    UBX_MGA_INI_TIME_GNSS = 0x40,
    UBX_MGA_INI_CLKD = 0x40,
    UBX_MGA_INI_FREQ = 0x40,
    UBX_MGA_INI_EOP = 0x40,
    UBX_MGA_QZSS_EPH = 0x05,
    UBX_MGA_QZSS_ALM = 0x05,
    UBX_MGA_QZSS_HEALTH = 0x05,
};
 
enum UbxMonMessages
{
    UBX_MON_BATCH = 0x32,
    UBX_MON_GNSS = 0x28,
    UBX_MON_HW2 = 0x0B,
    UBX_MON_HW = 0x09,
    UBX_MON_IO = 0x02,
    UBX_MON_MSGPP = 0x06,
    UBX_MON_PATCH = 0x27,
    UBX_MON_RXBUFF = 0x07,
    UBX_MON_RXR = 0x21,
    UBX_MON_SMGR = 0x2E,
    UBX_MON_TXBUFF = 0x08,
    UBX_MON_VER = 0x04,
};
 
enum UbxNavMessages
{
    UBX_NAV_AOPSTATUS = 0x60,
    UBX_NAV_ATT = 0x05,
    UBX_NAV_CLOCK = 0x22,
    UBX_NAV_DGPS = 0x31,
    UBX_NAV_DOP = 0x04,
    UBX_NAV_EOE = 0x61,
    UBX_NAV_GEOFENCE = 0x39,
    UBX_NAV_HPPOSECEF = 0x13,
    UBX_NAV_HPPOSLLH = 0x14,
    UBX_NAV_ODO = 0x09,
    UBX_NAV_ORB = 0x34,
    UBX_NAV_POSECEF = 0x01,
    UBX_NAV_POSLLH = 0x02,
    UBX_NAV_PVT = 0x07,
    UBX_NAV_RELPOSNED = 0x3C,
    UBX_NAV_RESETODO = 0x10,
    UBX_NAV_SAT = 0x35,
    UBX_NAV_SBAS = 0x32,
    UBX_NAV_SLAS = 0x42,
    UBX_NAV_SOL = 0x06,
    UBX_NAV_STATUS = 0x03,
    UBX_NAV_SVINFO = 0x30,
    UBX_NAV_SVIN = 0x3B,
    UBX_NAV_TIMEBDS = 0x24,
    UBX_NAV_TIMEGAL = 0x25,
    UBX_NAV_TIMEGLO = 0x23,
    UBX_NAV_TIMEGPS = 0x20,
    UBX_NAV_TIMELS = 0x26,
    UBX_NAV_TIMEUTC = 0x21,
    UBX_NAV_VELECEF = 0x11,
    UBX_NAV_VELNED = 0x12,
};
 
struct UbxNavAtt
{
    uint32_t iTOW = 0;                  
    uint8_t version = 0;                
    std::array<uint8_t, 3> reserved1{}; 
    int32_t roll = 0;                   
    int32_t pitch = 0;                  
    int32_t heading = 0;                
    uint32_t accRoll = 0;               
    uint32_t accPitch = 0;              
    uint32_t accHeading = 0;            
};
 
struct UbxNavPosecef
{
    uint32_t iTOW = 0; 
    int32_t ecefX = 0; 
    int32_t ecefY = 0; 
    int32_t ecefZ = 0; 
    uint32_t pAcc = 0; 
};
 
struct UbxNavPosllh
{
    uint32_t iTOW = 0;  
    int32_t lon = 0;    
    int32_t lat = 0;    
    int32_t height = 0; 
    int32_t hMSL = 0;   
    uint32_t hAcc = 0;  
    uint32_t vAcc = 0;  
};
 
struct UbxNavVelned
{
    uint32_t iTOW = 0;   
    int32_t velN = 0;    
    int32_t velE = 0;    
    int32_t velD = 0;    
    uint32_t speed = 0;  
    uint32_t gSpeed = 0; 
    int32_t heading = 0; 
    uint32_t sAcc = 0;   
    uint32_t cAcc = 0;   
};
 
enum UbxRxmMessages
{
    UBX_RXM_IMES = 0x61,
    UBX_RXM_MEASX = 0x14,
    UBX_RXM_PMREQ = 0x41,
    UBX_RXM_RAWX = 0x15,
    UBX_RXM_RLM = 0x59,
    UBX_RXM_RTCM = 0x32,
    UBX_RXM_SFRBX = 0x13,
    UBX_RXM_SVSI = 0x20,
};
 
struct UbxRxmRawx
{
    struct UbxRxmRawxData
    {
        double prMes = 0.0;
        double cpMes = 0.0;
        float doMes = 0.0F;             
        uint8_t gnssId = 0;             
        uint8_t svId = 0;               
        uint8_t sigId = 0;              
        uint8_t freqId = 0;             
        uint16_t locktime = 0;          
        uint8_t cno = 0;                
        std::bitset<1UL * 8UL> prStdev; 
        std::bitset<1UL * 8UL> cpStdev; 
        std::bitset<1UL * 8UL> doStdev; 
        std::bitset<1UL * 8UL> trkStat; 
        uint8_t reserved2 = 0;          
 
        [[nodiscard]] bool prValid() const { return trkStat[0]; }
 
        [[nodiscard]] bool cpValid() const { return trkStat[1]; }
 
        [[nodiscard]] bool halfCycValid() const { return trkStat[2]; }
 
        [[nodiscard]] bool subHalfSubtractedFromPhase() const { return trkStat[3]; }
    };
 
    double rcvTow = 0.0;
    uint16_t week = 0; 
    int8_t leapS = 0;
    uint8_t numMeas = 0;                
    std::bitset<1UL * 8UL> recStat;     
    uint8_t version = 0;                
    std::array<uint8_t, 2> reserved1{}; 
    std::vector<UbxRxmRawxData> data;   
};
 
struct UbxRxmSfrbx
{
    uint8_t gnssId = 0;         
    uint8_t svId = 0;           
    uint8_t sigId = 0;          
    uint8_t freqId = 0;         
    uint8_t numWords = 0;       
    uint8_t chn = 0;            
    uint8_t version = 0;        
    uint8_t reserved0 = 0;      
    std::vector<uint32_t> dwrd; 
 
    // TODO: Make this into functions
    // uint8_t subFrameId = 0; ///< bit 20-22 of word 2/dwrd[1]. 3 bits subframe id (HOW = Handover Word) of GPS
    // uint8_t wrdType = 0;    ///< bit 3-8 of dwrd[0]. 6 bits word types of Galileo I/NAV
};
 
enum UbxSecMessages
{
    UBX_SEC_UNIQID = 0x03,
};
 
enum UbxTimMessages
{
    UBX_TIM_FCHG = 0x16,
    UBX_TIM_HOC = 0x17,
    UBX_TIM_SMEAS = 0x13,
    UBX_TIM_SVIN = 0x04,
    UBX_TIM_TM2 = 0x03,
    UBX_TIM_TOS = 0x12,
    UBX_TIM_TP = 0x01,
    UBX_TIM_VCOCAL = 0x15,
    UBX_TIM_VRFY = 0x06,
};
 
enum UbxUpdMessages
{
    UBX_UPD_SOS = 0x14,
};
 
[[nodiscard]] UbxClass getMsgClassFromString(const std::string& className);
 
[[nodiscard]] uint8_t getMsgIdFromString(UbxClass msgClass, const std::string& idName);
 
[[nodiscard]] uint8_t getMsgIdFromString(const std::string& className, const std::string& idName);
 
[[nodiscard]] std::string getStringFromMsgClass(UbxClass msgClass);
 
[[nodiscard]] std::string getStringFromMsgId(UbxClass msgClass, uint8_t msgId);
 
[[nodiscard]] SatelliteSystem getSatSys(uint8_t gnssId);
 
[[nodiscard]] Code getCode(uint8_t gnssId, uint8_t sigId);
 
} // namespace NAV::vendor::ublox
 
std::ostream& operator<<(std::ostream& os, const NAV::vendor::ublox::UbxClass& obj);
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::vendor::ublox::ErrorDetectionMode> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::NmeaTalkerID> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::NmeaMessageClass> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::NmeaStandardMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::NmeaPubxMessages> : ostream_formatter
{};
 
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxClass> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::vendor::ublox::UbxClass& ubxClass, FormatContext& ctx)
    {
        return fmt::formatter<std::string>::format(NAV::vendor::ublox::getStringFromMsgClass(ubxClass), ctx);
    }
};
 
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxAckMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxCfgMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxEsfMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxHnrMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxInfMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxLogMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxMgaMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxMonMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxNavMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxRxmMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxSecMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxTimMessages> : ostream_formatter
{};
template<>
struct fmt::formatter<NAV::vendor::ublox::UbxUpdMessages> : ostream_formatter
{};
 
#endif