commands_rtk.hpp

Go to the documentation of this file.

#pragma once
 
#include <mip/definitions/common.hpp>
#include <mip/mip_descriptors.hpp>
#include <mip/mip_result.hpp>
#include <mip/mip_interface.hpp>
 
#include <stdint.h>
#include <stddef.h>
 
namespace mip {
namespace C {
struct mip_interface;
} // namespace C
 
namespace commands_rtk {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                   = 0x0F,
    
    CMD_GET_STATUS_FLAGS             = 0x01,
    CMD_GET_IMEI                     = 0x02,
    CMD_GET_IMSI                     = 0x03,
    CMD_GET_ICCID                    = 0x04,
    CMD_GET_RSSI                     = 0x05,
    CMD_CONNECTED_DEVICE_TYPE        = 0x06,
    CMD_GET_ACT_CODE                 = 0x07,
    CMD_GET_MODEM_FIRMWARE_VERSION   = 0x08,
    CMD_SERVICE_STATUS               = 0x0A,
    CMD_PROD_ERASE_STORAGE           = 0x20,
    CMD_CONTROL                      = 0x21,
    CMD_MODEM_HARD_RESET             = 0x22,
    
    REPLY_GET_STATUS_FLAGS           = 0x81,
    REPLY_GET_IMEI                   = 0x82,
    REPLY_GET_IMSI                   = 0x83,
    REPLY_GET_ICCID                  = 0x84,
    REPLY_CONNECTED_DEVICE_TYPE      = 0x86,
    REPLY_GET_ACT_CODE               = 0x87,
    REPLY_GET_MODEM_FIRMWARE_VERSION = 0x88,
    REPLY_GET_RSSI                   = 0x85,
    REPLY_SERVICE_STATUS             = 0x8A,
};
 
// Shared Type Definitions
 
enum class MediaSelector : uint8_t
{
    MEDIA_EXTERNALFLASH = 0,  
    MEDIA_SD            = 1,  
};
 
enum class LedAction : uint8_t
{
    LED_NONE    = 0,  
    LED_FLASH   = 1,  
    LED_PULSATE = 2,  
};
 
 
// Mip Fields
 
 
struct GetStatusFlags
{
    struct StatusFlagsLegacy : Bitfield<StatusFlagsLegacy>
    {
        typedef uint32_t Type;
        enum _enumType : uint32_t
        {
            NONE                 = 0x00000000,
            CONTROLLERSTATE      = 0x00000007,  
            PLATFORMSTATE        = 0x000000F8,  
            CONTROLLERSTATUSCODE = 0x00000700,  
            PLATFORMSTATUSCODE   = 0x00003800,  
            RESETCODE            = 0x0000C000,  
            SIGNALQUALITY        = 0x000F0000,  
            RESERVED             = 0xFFF00000,  
            RSSI                 = 0x03F00000,  
            RSRP                 = 0x0C000000,  
            RSRQ                 = 0x30000000,  
            SINR                 = 0xC0000000,  
            ALL                  = 0xFFFFFFFF,
        };
        uint32_t value = NONE;
        
        StatusFlagsLegacy() : value(NONE) {}
        StatusFlagsLegacy(int val) : value((uint32_t)val) {}
        operator uint32_t() const { return value; }
        StatusFlagsLegacy& operator=(uint32_t val) { value = val; return *this; }
        StatusFlagsLegacy& operator=(int val) { value = uint32_t(val); return *this; }
        StatusFlagsLegacy& operator|=(uint32_t val) { return *this = value | val; }
        StatusFlagsLegacy& operator&=(uint32_t val) { return *this = value & val; }
        
        uint32_t controllerstate() const { return (value & CONTROLLERSTATE) >> 0; }
        void controllerstate(uint32_t val) { value = (value & ~CONTROLLERSTATE) | (val << 0); }
        uint32_t platformstate() const { return (value & PLATFORMSTATE) >> 3; }
        void platformstate(uint32_t val) { value = (value & ~PLATFORMSTATE) | (val << 3); }
        uint32_t controllerstatuscode() const { return (value & CONTROLLERSTATUSCODE) >> 8; }
        void controllerstatuscode(uint32_t val) { value = (value & ~CONTROLLERSTATUSCODE) | (val << 8); }
        uint32_t platformstatuscode() const { return (value & PLATFORMSTATUSCODE) >> 11; }
        void platformstatuscode(uint32_t val) { value = (value & ~PLATFORMSTATUSCODE) | (val << 11); }
        uint32_t resetcode() const { return (value & RESETCODE) >> 14; }
        void resetcode(uint32_t val) { value = (value & ~RESETCODE) | (val << 14); }
        uint32_t signalquality() const { return (value & SIGNALQUALITY) >> 16; }
        void signalquality(uint32_t val) { value = (value & ~SIGNALQUALITY) | (val << 16); }
        uint32_t reserved() const { return (value & RESERVED) >> 20; }
        void reserved(uint32_t val) { value = (value & ~RESERVED) | (val << 20); }
        uint32_t rssi() const { return (value & RSSI) >> 20; }
        void rssi(uint32_t val) { value = (value & ~RSSI) | (val << 20); }
        uint32_t rsrp() const { return (value & RSRP) >> 26; }
        void rsrp(uint32_t val) { value = (value & ~RSRP) | (val << 26); }
        uint32_t rsrq() const { return (value & RSRQ) >> 28; }
        void rsrq(uint32_t val) { value = (value & ~RSRQ) | (val << 28); }
        uint32_t sinr() const { return (value & SINR) >> 30; }
        void sinr(uint32_t val) { value = (value & ~SINR) | (val << 30); }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    struct StatusFlags : Bitfield<StatusFlags>
    {
        typedef uint32_t Type;
        enum _enumType : uint32_t
        {
            NONE                    = 0x00000000,
            MODEM_STATE             = 0x0000000F,  
            CONNECTION_TYPE         = 0x000000F0,  
            RSSI                    = 0x0000FF00,  
            SIGNAL_QUALITY          = 0x000F0000,  
            TOWER_CHANGE_INDICATOR  = 0x00F00000,  
            NMEA_TIMEOUT            = 0x01000000,  
            SERVER_TIMEOUT          = 0x02000000,  
            CORRECTIONS_TIMEOUT     = 0x04000000,  
            DEVICE_OUT_OF_RANGE     = 0x08000000,  
            CORRECTIONS_UNAVAILABLE = 0x10000000,  
            RESERVED                = 0x20000000,  
            VERSION                 = 0xC0000000,  
            ALL                     = 0xFFFFFFFF,
        };
        uint32_t value = NONE;
        
        StatusFlags() : value(NONE) {}
        StatusFlags(int val) : value((uint32_t)val) {}
        operator uint32_t() const { return value; }
        StatusFlags& operator=(uint32_t val) { value = val; return *this; }
        StatusFlags& operator=(int val) { value = uint32_t(val); return *this; }
        StatusFlags& operator|=(uint32_t val) { return *this = value | val; }
        StatusFlags& operator&=(uint32_t val) { return *this = value & val; }
        
        uint32_t modemState() const { return (value & MODEM_STATE) >> 0; }
        void modemState(uint32_t val) { value = (value & ~MODEM_STATE) | (val << 0); }
        uint32_t connectionType() const { return (value & CONNECTION_TYPE) >> 4; }
        void connectionType(uint32_t val) { value = (value & ~CONNECTION_TYPE) | (val << 4); }
        uint32_t rssi() const { return (value & RSSI) >> 8; }
        void rssi(uint32_t val) { value = (value & ~RSSI) | (val << 8); }
        uint32_t signalQuality() const { return (value & SIGNAL_QUALITY) >> 16; }
        void signalQuality(uint32_t val) { value = (value & ~SIGNAL_QUALITY) | (val << 16); }
        uint32_t towerChangeIndicator() const { return (value & TOWER_CHANGE_INDICATOR) >> 20; }
        void towerChangeIndicator(uint32_t val) { value = (value & ~TOWER_CHANGE_INDICATOR) | (val << 20); }
        bool nmeaTimeout() const { return (value & NMEA_TIMEOUT) > 0; }
        void nmeaTimeout(bool val) { value &= ~NMEA_TIMEOUT; if(val) value |= NMEA_TIMEOUT; }
        bool serverTimeout() const { return (value & SERVER_TIMEOUT) > 0; }
        void serverTimeout(bool val) { value &= ~SERVER_TIMEOUT; if(val) value |= SERVER_TIMEOUT; }
        bool correctionsTimeout() const { return (value & CORRECTIONS_TIMEOUT) > 0; }
        void correctionsTimeout(bool val) { value &= ~CORRECTIONS_TIMEOUT; if(val) value |= CORRECTIONS_TIMEOUT; }
        bool deviceOutOfRange() const { return (value & DEVICE_OUT_OF_RANGE) > 0; }
        void deviceOutOfRange(bool val) { value &= ~DEVICE_OUT_OF_RANGE; if(val) value |= DEVICE_OUT_OF_RANGE; }
        bool correctionsUnavailable() const { return (value & CORRECTIONS_UNAVAILABLE) > 0; }
        void correctionsUnavailable(bool val) { value &= ~CORRECTIONS_UNAVAILABLE; if(val) value |= CORRECTIONS_UNAVAILABLE; }
        bool reserved() const { return (value & RESERVED) > 0; }
        void reserved(bool val) { value &= ~RESERVED; if(val) value |= RESERVED; }
        uint32_t version() const { return (value & VERSION) >> 30; }
        void version(uint32_t val) { value = (value & ~VERSION) | (val << 30); }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_STATUS_FLAGS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetStatusFlags";
    static constexpr const char* DOC_NAME = "Get RTK Device Status Flags";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        StatusFlags flags; 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_STATUS_FLAGS;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetStatusFlags::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device Status Flags Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(flags);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(flags));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetStatusFlags> getStatusFlags(C::mip_interface& device, GetStatusFlags::StatusFlags* flagsOut);
 
 
struct GetImei
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_IMEI;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetImei";
    static constexpr const char* DOC_NAME = "Get RTK Device IMEI (International Mobile Equipment Identifier)";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        char IMEI[32] = {0};
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_IMEI;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetImei::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device IMEI (International Mobile Equipment Identifier) Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(IMEI);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(IMEI));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetImei> getImei(C::mip_interface& device, char* imeiOut);
 
 
struct GetImsi
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_IMSI;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetImsi";
    static constexpr const char* DOC_NAME = "Get RTK Device IMSI (International Mobile Subscriber Identifier)";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        char IMSI[32] = {0};
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_IMSI;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetImsi::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device IMSI (International Mobile Subscriber Identifier) Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(IMSI);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(IMSI));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetImsi> getImsi(C::mip_interface& device, char* imsiOut);
 
 
struct GetIccid
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_ICCID;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetIccid";
    static constexpr const char* DOC_NAME = "Get RTK Device ICCID (Integrated Circuit Card Identification [SIM Number])";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        char ICCID[32] = {0};
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_ICCID;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetIccid::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device ICCID (Integrated Circuit Card Identification [SIM Number]) Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(ICCID);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(ICCID));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetIccid> getIccid(C::mip_interface& device, char* iccidOut);
 
 
struct ConnectedDeviceType
{
    enum class Type : uint8_t
    {
        GENERIC = 0,  
        GQ7     = 1,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    Type devType = static_cast<Type>(0);
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_CONNECTED_DEVICE_TYPE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ConnectedDeviceType";
    static constexpr const char* DOC_NAME = "Configure or read the type of the connected device";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(devType);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(devType));
    }
    
    static ConnectedDeviceType create_sld_all(::mip::FunctionSelector function)
    {
        ConnectedDeviceType cmd;
        cmd.function = function;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        Type devType = static_cast<Type>(0);
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_CONNECTED_DEVICE_TYPE;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "ConnectedDeviceType::Response";
        static constexpr const char* DOC_NAME = "Configure or read the type of the connected device Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(devType);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(devType));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<ConnectedDeviceType> writeConnectedDeviceType(C::mip_interface& device, ConnectedDeviceType::Type devtype);
TypedResult<ConnectedDeviceType> readConnectedDeviceType(C::mip_interface& device, ConnectedDeviceType::Type* devtypeOut);
TypedResult<ConnectedDeviceType> saveConnectedDeviceType(C::mip_interface& device);
TypedResult<ConnectedDeviceType> loadConnectedDeviceType(C::mip_interface& device);
TypedResult<ConnectedDeviceType> defaultConnectedDeviceType(C::mip_interface& device);
 
 
struct GetActCode
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_ACT_CODE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetActCode";
    static constexpr const char* DOC_NAME = "Get RTK Device Activation Code";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        char ActivationCode[32] = {0};
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_ACT_CODE;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetActCode::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device Activation Code Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(ActivationCode);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(ActivationCode));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetActCode> getActCode(C::mip_interface& device, char* activationcodeOut);
 
 
struct GetModemFirmwareVersion
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_MODEM_FIRMWARE_VERSION;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetModemFirmwareVersion";
    static constexpr const char* DOC_NAME = "Get RTK Device's Cell Modem Firmware version number";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        char ModemFirmwareVersion[32] = {0};
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_MODEM_FIRMWARE_VERSION;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetModemFirmwareVersion::Response";
        static constexpr const char* DOC_NAME = "Get RTK Device's Cell Modem Firmware version number Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(ModemFirmwareVersion);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(ModemFirmwareVersion));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetModemFirmwareVersion> getModemFirmwareVersion(C::mip_interface& device, char* modemfirmwareversionOut);
 
 
struct GetRssi
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_GET_RSSI;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetRssi";
    static constexpr const char* DOC_NAME = "GetRssi";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        bool valid = 0;
        int32_t rssi = 0;
        int32_t signalQuality = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_GET_RSSI;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetRssi::Response";
        static constexpr const char* DOC_NAME = "GetRssi Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(valid,rssi,signalQuality);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(valid),std::ref(rssi),std::ref(signalQuality));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetRssi> getRssi(C::mip_interface& device, bool* validOut, int32_t* rssiOut, int32_t* signalqualityOut);
 
 
struct ServiceStatus
{
    struct ServiceFlags : Bitfield<ServiceFlags>
    {
        typedef uint8_t Type;
        enum _enumType : uint8_t
        {
            NONE                    = 0x00,
            THROTTLE                = 0x01,  
            CORRECTIONS_UNAVAILABLE = 0x02,  
            RESERVED                = 0xFC,  
            ALL                     = 0xFF,
        };
        uint8_t value = NONE;
        
        ServiceFlags() : value(NONE) {}
        ServiceFlags(int val) : value((uint8_t)val) {}
        operator uint8_t() const { return value; }
        ServiceFlags& operator=(uint8_t val) { value = val; return *this; }
        ServiceFlags& operator=(int val) { value = uint8_t(val); return *this; }
        ServiceFlags& operator|=(uint8_t val) { return *this = value | val; }
        ServiceFlags& operator&=(uint8_t val) { return *this = value & val; }
        
        bool throttle() const { return (value & THROTTLE) > 0; }
        void throttle(bool val) { value &= ~THROTTLE; if(val) value |= THROTTLE; }
        bool correctionsUnavailable() const { return (value & CORRECTIONS_UNAVAILABLE) > 0; }
        void correctionsUnavailable(bool val) { value &= ~CORRECTIONS_UNAVAILABLE; if(val) value |= CORRECTIONS_UNAVAILABLE; }
        uint8_t reserved() const { return (value & RESERVED) >> 2; }
        void reserved(uint8_t val) { value = (value & ~RESERVED) | (val << 2); }
        bool allSet() const { return value == ALL; }
        void setAll() { value |= ALL; }
    };
    uint32_t reserved1 = 0;
    uint32_t reserved2 = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_SERVICE_STATUS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ServiceStatus";
    static constexpr const char* DOC_NAME = "ServiceStatus";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(reserved1,reserved2);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(reserved1),std::ref(reserved2));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        ServiceFlags flags;
        uint32_t receivedBytes = 0;
        uint32_t lastBytes = 0;
        uint64_t lastBytesTime = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::REPLY_SERVICE_STATUS;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "ServiceStatus::Response";
        static constexpr const char* DOC_NAME = "ServiceStatus Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(flags,receivedBytes,lastBytes,lastBytesTime);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(flags),std::ref(receivedBytes),std::ref(lastBytes),std::ref(lastBytesTime));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<ServiceStatus> serviceStatus(C::mip_interface& device, uint32_t reserved1, uint32_t reserved2, ServiceStatus::ServiceFlags* flagsOut, uint32_t* receivedbytesOut, uint32_t* lastbytesOut, uint64_t* lastbytestimeOut);
 
 
struct ProdEraseStorage
{
    MediaSelector media = static_cast<MediaSelector>(0);
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_PROD_ERASE_STORAGE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ProdEraseStorage";
    static constexpr const char* DOC_NAME = "ProdEraseStorage";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(media);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(media));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<ProdEraseStorage> prodEraseStorage(C::mip_interface& device, MediaSelector media);
 
 
struct LedControl
{
    uint8_t primaryColor[3] = {0};
    uint8_t altColor[3] = {0};
    LedAction act = static_cast<LedAction>(0);
    uint32_t period = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_CONTROL;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "LedControl";
    static constexpr const char* DOC_NAME = "LedControl";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple(primaryColor,altColor,act,period);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(primaryColor),std::ref(altColor),std::ref(act),std::ref(period));
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<LedControl> ledControl(C::mip_interface& device, const uint8_t* primarycolor, const uint8_t* altcolor, LedAction act, uint32_t period);
 
 
struct ModemHardReset
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_rtk::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_rtk::CMD_MODEM_HARD_RESET;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ModemHardReset";
    static constexpr const char* DOC_NAME = "ModemHardReset";
    static constexpr const bool HAS_FUNCTION_SELECTOR = false;
    
    auto asTuple() const
    {
        return std::make_tuple();
    }
    
    auto asTuple()
    {
        return std::make_tuple();
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<ModemHardReset> modemHardReset(C::mip_interface& device);
 
 
} // namespace commands_rtk
} // namespace mip