commands_base.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_base {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET                 = 0x01,
    
    CMD_PING                       = 0x01,
    CMD_SET_TO_IDLE                = 0x02,
    CMD_GET_DEVICE_INFO            = 0x03,
    CMD_GET_DEVICE_DESCRIPTORS     = 0x04,
    CMD_BUILT_IN_TEST              = 0x05,
    CMD_RESUME                     = 0x06,
    CMD_GET_EXTENDED_DESCRIPTORS   = 0x07,
    CMD_CONTINUOUS_BIT             = 0x08,
    CMD_COMM_SPEED                 = 0x09,
    CMD_GPS_TIME_UPDATE            = 0x72,
    CMD_SOFT_RESET                 = 0x7E,
    
    REPLY_DEVICE_INFO              = 0x81,
    REPLY_DEVICE_DESCRIPTORS       = 0x82,
    REPLY_BUILT_IN_TEST            = 0x83,
    REPLY_GPS_CORRELATION_WEEK     = 0x84,
    REPLY_GPS_CORRELATION_SECONDS  = 0x85,
    REPLY_GET_EXTENDED_DESCRIPTORS = 0x86,
    REPLY_CONTINUOUS_BIT           = 0x88,
    REPLY_COMM_SPEED               = 0x89,
};
 
// Shared Type Definitions
 
struct BaseDeviceInfo
{
    uint16_t firmware_version = 0;
    char model_name[16] = {0};
    char model_number[16] = {0};
    char serial_number[16] = {0};
    char lot_number[16] = {0};
    char device_options[16] = {0};
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
};
enum class TimeFormat : uint8_t
{
    GPS = 1,  
};
 
struct CommandedTestBitsGq7 : Bitfield<CommandedTestBitsGq7>
{
    typedef uint32_t Type;
    enum _enumType : uint32_t
    {
        NONE                   = 0x00000000,
        GENERAL_HARDWARE_FAULT = 0x00000001,  
        GENERAL_FIRMWARE_FAULT = 0x00000002,  
        TIMING_OVERLOAD        = 0x00000004,  
        BUFFER_OVERRUN         = 0x00000008,  
        RESERVED               = 0x000000F0,  
        IPC_IMU_FAULT          = 0x00000100,  
        IPC_NAV_FAULT          = 0x00000200,  
        IPC_GNSS_FAULT         = 0x00000400,  
        COMMS_FAULT            = 0x00000800,  
        IMU_ACCEL_FAULT        = 0x00001000,  
        IMU_GYRO_FAULT         = 0x00002000,  
        IMU_MAG_FAULT          = 0x00004000,  
        IMU_PRESS_FAULT        = 0x00008000,  
        IMU_RESERVED           = 0x00030000,  
        IMU_CAL_ERROR          = 0x00040000,  
        IMU_GENERAL_FAULT      = 0x00080000,  
        FILT_RESERVED          = 0x00300000,  
        FILT_SOLUTION_FAULT    = 0x00400000,  
        FILT_GENERAL_FAULT     = 0x00800000,  
        GNSS_RECEIVER1_FAULT   = 0x01000000,  
        GNSS_ANTENNA1_FAULT    = 0x02000000,  
        GNSS_RECEIVER2_FAULT   = 0x04000000,  
        GNSS_ANTENNA2_FAULT    = 0x08000000,  
        GNSS_RTCM_FAILURE      = 0x10000000,  
        GNSS_RTK_FAULT         = 0x20000000,  
        GNSS_SOLUTION_FAULT    = 0x40000000,  
        GNSS_GENERAL_FAULT     = 0x80000000,  
        ALL                    = 0xFFFFFFFF,
    };
    uint32_t value = NONE;
    
    CommandedTestBitsGq7() : value(NONE) {}
    CommandedTestBitsGq7(int val) : value((uint32_t)val) {}
    operator uint32_t() const { return value; }
    CommandedTestBitsGq7& operator=(uint32_t val) { value = val; return *this; }
    CommandedTestBitsGq7& operator=(int val) { value = uint32_t(val); return *this; }
    CommandedTestBitsGq7& operator|=(uint32_t val) { return *this = value | val; }
    CommandedTestBitsGq7& operator&=(uint32_t val) { return *this = value & val; }
    
    bool generalHardwareFault() const { return (value & GENERAL_HARDWARE_FAULT) > 0; }
    void generalHardwareFault(bool val) { value &= ~GENERAL_HARDWARE_FAULT; if(val) value |= GENERAL_HARDWARE_FAULT; }
    bool generalFirmwareFault() const { return (value & GENERAL_FIRMWARE_FAULT) > 0; }
    void generalFirmwareFault(bool val) { value &= ~GENERAL_FIRMWARE_FAULT; if(val) value |= GENERAL_FIRMWARE_FAULT; }
    bool timingOverload() const { return (value & TIMING_OVERLOAD) > 0; }
    void timingOverload(bool val) { value &= ~TIMING_OVERLOAD; if(val) value |= TIMING_OVERLOAD; }
    bool bufferOverrun() const { return (value & BUFFER_OVERRUN) > 0; }
    void bufferOverrun(bool val) { value &= ~BUFFER_OVERRUN; if(val) value |= BUFFER_OVERRUN; }
    uint32_t reserved() const { return (value & RESERVED) >> 4; }
    void reserved(uint32_t val) { value = (value & ~RESERVED) | (val << 4); }
    bool ipcImuFault() const { return (value & IPC_IMU_FAULT) > 0; }
    void ipcImuFault(bool val) { value &= ~IPC_IMU_FAULT; if(val) value |= IPC_IMU_FAULT; }
    bool ipcNavFault() const { return (value & IPC_NAV_FAULT) > 0; }
    void ipcNavFault(bool val) { value &= ~IPC_NAV_FAULT; if(val) value |= IPC_NAV_FAULT; }
    bool ipcGnssFault() const { return (value & IPC_GNSS_FAULT) > 0; }
    void ipcGnssFault(bool val) { value &= ~IPC_GNSS_FAULT; if(val) value |= IPC_GNSS_FAULT; }
    bool commsFault() const { return (value & COMMS_FAULT) > 0; }
    void commsFault(bool val) { value &= ~COMMS_FAULT; if(val) value |= COMMS_FAULT; }
    bool imuAccelFault() const { return (value & IMU_ACCEL_FAULT) > 0; }
    void imuAccelFault(bool val) { value &= ~IMU_ACCEL_FAULT; if(val) value |= IMU_ACCEL_FAULT; }
    bool imuGyroFault() const { return (value & IMU_GYRO_FAULT) > 0; }
    void imuGyroFault(bool val) { value &= ~IMU_GYRO_FAULT; if(val) value |= IMU_GYRO_FAULT; }
    bool imuMagFault() const { return (value & IMU_MAG_FAULT) > 0; }
    void imuMagFault(bool val) { value &= ~IMU_MAG_FAULT; if(val) value |= IMU_MAG_FAULT; }
    bool imuPressFault() const { return (value & IMU_PRESS_FAULT) > 0; }
    void imuPressFault(bool val) { value &= ~IMU_PRESS_FAULT; if(val) value |= IMU_PRESS_FAULT; }
    uint32_t imuReserved() const { return (value & IMU_RESERVED) >> 16; }
    void imuReserved(uint32_t val) { value = (value & ~IMU_RESERVED) | (val << 16); }
    bool imuCalError() const { return (value & IMU_CAL_ERROR) > 0; }
    void imuCalError(bool val) { value &= ~IMU_CAL_ERROR; if(val) value |= IMU_CAL_ERROR; }
    bool imuGeneralFault() const { return (value & IMU_GENERAL_FAULT) > 0; }
    void imuGeneralFault(bool val) { value &= ~IMU_GENERAL_FAULT; if(val) value |= IMU_GENERAL_FAULT; }
    uint32_t filtReserved() const { return (value & FILT_RESERVED) >> 20; }
    void filtReserved(uint32_t val) { value = (value & ~FILT_RESERVED) | (val << 20); }
    bool filtSolutionFault() const { return (value & FILT_SOLUTION_FAULT) > 0; }
    void filtSolutionFault(bool val) { value &= ~FILT_SOLUTION_FAULT; if(val) value |= FILT_SOLUTION_FAULT; }
    bool filtGeneralFault() const { return (value & FILT_GENERAL_FAULT) > 0; }
    void filtGeneralFault(bool val) { value &= ~FILT_GENERAL_FAULT; if(val) value |= FILT_GENERAL_FAULT; }
    bool gnssReceiver1Fault() const { return (value & GNSS_RECEIVER1_FAULT) > 0; }
    void gnssReceiver1Fault(bool val) { value &= ~GNSS_RECEIVER1_FAULT; if(val) value |= GNSS_RECEIVER1_FAULT; }
    bool gnssAntenna1Fault() const { return (value & GNSS_ANTENNA1_FAULT) > 0; }
    void gnssAntenna1Fault(bool val) { value &= ~GNSS_ANTENNA1_FAULT; if(val) value |= GNSS_ANTENNA1_FAULT; }
    bool gnssReceiver2Fault() const { return (value & GNSS_RECEIVER2_FAULT) > 0; }
    void gnssReceiver2Fault(bool val) { value &= ~GNSS_RECEIVER2_FAULT; if(val) value |= GNSS_RECEIVER2_FAULT; }
    bool gnssAntenna2Fault() const { return (value & GNSS_ANTENNA2_FAULT) > 0; }
    void gnssAntenna2Fault(bool val) { value &= ~GNSS_ANTENNA2_FAULT; if(val) value |= GNSS_ANTENNA2_FAULT; }
    bool gnssRtcmFailure() const { return (value & GNSS_RTCM_FAILURE) > 0; }
    void gnssRtcmFailure(bool val) { value &= ~GNSS_RTCM_FAILURE; if(val) value |= GNSS_RTCM_FAILURE; }
    bool gnssRtkFault() const { return (value & GNSS_RTK_FAULT) > 0; }
    void gnssRtkFault(bool val) { value &= ~GNSS_RTK_FAULT; if(val) value |= GNSS_RTK_FAULT; }
    bool gnssSolutionFault() const { return (value & GNSS_SOLUTION_FAULT) > 0; }
    void gnssSolutionFault(bool val) { value &= ~GNSS_SOLUTION_FAULT; if(val) value |= GNSS_SOLUTION_FAULT; }
    bool gnssGeneralFault() const { return (value & GNSS_GENERAL_FAULT) > 0; }
    void gnssGeneralFault(bool val) { value &= ~GNSS_GENERAL_FAULT; if(val) value |= GNSS_GENERAL_FAULT; }
    bool allSet() const { return value == ALL; }
    void setAll() { value |= ALL; }
};
 
// Mip Fields
 
 
struct Ping
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_PING;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "Ping";
    static constexpr const char* DOC_NAME = "Ping";
    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<Ping> ping(C::mip_interface& device);
 
 
struct SetIdle
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_SET_TO_IDLE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "SetIdle";
    static constexpr const char* DOC_NAME = "Set to idle";
    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<SetIdle> setIdle(C::mip_interface& device);
 
 
struct GetDeviceInfo
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_DEVICE_INFO;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetDeviceInfo";
    static constexpr const char* DOC_NAME = "Get device information";
    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
    {
        BaseDeviceInfo device_info;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_DEVICE_INFO;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetDeviceInfo::Response";
        static constexpr const char* DOC_NAME = "Get device information Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(device_info);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(device_info));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetDeviceInfo> getDeviceInfo(C::mip_interface& device, BaseDeviceInfo* deviceInfoOut);
 
 
struct GetDeviceDescriptors
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_DEVICE_DESCRIPTORS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetDeviceDescriptors";
    static constexpr const char* DOC_NAME = "Get device descriptors";
    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
    {
        uint16_t descriptors[253] = {0};
        uint8_t descriptors_count = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_DEVICE_DESCRIPTORS;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetDeviceDescriptors::Response";
        static constexpr const char* DOC_NAME = "Get device descriptors Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(descriptors,descriptors_count);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(descriptors),std::ref(descriptors_count));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetDeviceDescriptors> getDeviceDescriptors(C::mip_interface& device, uint16_t* descriptorsOut, size_t descriptorsOutMax, uint8_t* descriptorsOutCount);
 
 
struct BuiltInTest
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_BUILT_IN_TEST;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "BuiltInTest";
    static constexpr const char* DOC_NAME = "Built in test";
    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
    {
        uint32_t result = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_BUILT_IN_TEST;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "BuiltInTest::Response";
        static constexpr const char* DOC_NAME = "Built in test Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(result);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(result));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<BuiltInTest> builtInTest(C::mip_interface& device, uint32_t* resultOut);
 
 
struct Resume
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_RESUME;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "Resume";
    static constexpr const char* DOC_NAME = "Resume";
    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<Resume> resume(C::mip_interface& device);
 
 
struct GetExtendedDescriptors
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_EXTENDED_DESCRIPTORS;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GetExtendedDescriptors";
    static constexpr const char* DOC_NAME = "Get device descriptors (extended)";
    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
    {
        uint16_t descriptors[253] = {0};
        uint8_t descriptors_count = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_GET_EXTENDED_DESCRIPTORS;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "GetExtendedDescriptors::Response";
        static constexpr const char* DOC_NAME = "Get device descriptors (extended) Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(descriptors,descriptors_count);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(descriptors),std::ref(descriptors_count));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<GetExtendedDescriptors> getExtendedDescriptors(C::mip_interface& device, uint16_t* descriptorsOut, size_t descriptorsOutMax, uint8_t* descriptorsOutCount);
 
 
struct ContinuousBit
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_CONTINUOUS_BIT;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "ContinuousBit";
    static constexpr const char* DOC_NAME = "Continuous built-in test";
    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
    {
        uint8_t result[16] = {0}; 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_CONTINUOUS_BIT;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "ContinuousBit::Response";
        static constexpr const char* DOC_NAME = "Continuous built-in test Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(result);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(result));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<ContinuousBit> continuousBit(C::mip_interface& device, uint8_t* resultOut);
 
 
struct CommSpeed
{
    static constexpr const uint32_t ALL_PORTS = 0;
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t port = 0; 
    uint32_t baud = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_COMM_SPEED;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CommSpeed";
    static constexpr const char* DOC_NAME = "Comm Port Speed";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(port,baud);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(port),std::ref(baud));
    }
    
    static CommSpeed create_sld_all(::mip::FunctionSelector function)
    {
        CommSpeed cmd;
        cmd.function = function;
        cmd.port = 0;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        uint8_t port = 0; 
        uint32_t baud = 0; 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_COMM_SPEED;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "CommSpeed::Response";
        static constexpr const char* DOC_NAME = "Comm Port Speed Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(port,baud);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(port),std::ref(baud));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<CommSpeed> writeCommSpeed(C::mip_interface& device, uint8_t port, uint32_t baud);
TypedResult<CommSpeed> readCommSpeed(C::mip_interface& device, uint8_t port, uint32_t* baudOut);
TypedResult<CommSpeed> saveCommSpeed(C::mip_interface& device, uint8_t port);
TypedResult<CommSpeed> loadCommSpeed(C::mip_interface& device, uint8_t port);
TypedResult<CommSpeed> defaultCommSpeed(C::mip_interface& device, uint8_t port);
 
 
struct GpsTimeUpdate
{
    enum class FieldId : uint8_t
    {
        WEEK_NUMBER  = 1,  
        TIME_OF_WEEK = 2,  
    };
    
    FunctionSelector function = static_cast<FunctionSelector>(0);
    FieldId field_id = static_cast<FieldId>(0); 
    uint32_t value = 0; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GPS_TIME_UPDATE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "GpsTimeUpdate";
    static constexpr const char* DOC_NAME = "GPS Time Update Command";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(field_id,value);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(field_id),std::ref(value));
    }
    
    static GpsTimeUpdate create_sld_all(::mip::FunctionSelector function)
    {
        GpsTimeUpdate cmd;
        cmd.function = function;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    typedef void Response;
};
TypedResult<GpsTimeUpdate> writeGpsTimeUpdate(C::mip_interface& device, GpsTimeUpdate::FieldId fieldId, uint32_t value);
 
 
struct SoftReset
{
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_SOFT_RESET;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "SoftReset";
    static constexpr const char* DOC_NAME = "Reset device";
    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<SoftReset> softReset(C::mip_interface& device);
 
 
} // namespace commands_base
} // namespace mip