commands_base.hpp

Go to the documentation of this file.

#pragma once
 
#include "descriptors.h"
#include "../mip_result.h"
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
namespace mip {
class Serializer;
 
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_BROADCAST         = 0x71,
    CMD_GPS_TIME_BROADCAST_NEW     = 0x72,
    CMD_SYSTEM_TIME                = 0x73,
    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 BaseDeviceInfo& self);
void extract(Serializer& serializer, BaseDeviceInfo& self);
 
enum class TimeFormat : uint8_t
{
    GPS = 1,  
};
 
struct CommandedTestBitsGq7 : Bitfield<CommandedTestBitsGq7>
{
    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,  
    };
    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 = val; return *this; }
    CommandedTestBitsGq7& operator|=(uint32_t val) { return *this = value | val; }
    CommandedTestBitsGq7& operator&=(uint32_t val) { return *this = value & val; }
};
 
 
// Mip Fields
 
 
struct Ping
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_PING;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const Ping& self);
void extract(Serializer& serializer, Ping& self);
 
CmdResult ping(C::mip_interface& device);
 
struct SetIdle
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_SET_TO_IDLE;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const SetIdle& self);
void extract(Serializer& serializer, SetIdle& self);
 
CmdResult setIdle(C::mip_interface& device);
 
struct GetDeviceInfo
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_DEVICE_INFO;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_DEVICE_INFO;
        
        BaseDeviceInfo device_info;
        
    };
};
void insert(Serializer& serializer, const GetDeviceInfo& self);
void extract(Serializer& serializer, GetDeviceInfo& self);
 
void insert(Serializer& serializer, const GetDeviceInfo::Response& self);
void extract(Serializer& serializer, GetDeviceInfo::Response& self);
 
CmdResult getDeviceInfo(C::mip_interface& device, BaseDeviceInfo* deviceInfoOut);
 
struct GetDeviceDescriptors
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_DEVICE_DESCRIPTORS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_DEVICE_DESCRIPTORS;
        
        uint8_t descriptors_count = 0;
        uint16_t* descriptors = {nullptr};
        
    };
};
void insert(Serializer& serializer, const GetDeviceDescriptors& self);
void extract(Serializer& serializer, GetDeviceDescriptors& self);
 
void insert(Serializer& serializer, const GetDeviceDescriptors::Response& self);
void extract(Serializer& serializer, GetDeviceDescriptors::Response& self);
 
CmdResult getDeviceDescriptors(C::mip_interface& device, uint16_t* descriptorsOut, size_t descriptorsOutMax, uint8_t* descriptorsOutCount);
 
struct BuiltInTest
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_BUILT_IN_TEST;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_BUILT_IN_TEST;
        
        uint32_t result = 0;
        
    };
};
void insert(Serializer& serializer, const BuiltInTest& self);
void extract(Serializer& serializer, BuiltInTest& self);
 
void insert(Serializer& serializer, const BuiltInTest::Response& self);
void extract(Serializer& serializer, BuiltInTest::Response& self);
 
CmdResult builtInTest(C::mip_interface& device, uint32_t* resultOut);
 
struct Resume
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_RESUME;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const Resume& self);
void extract(Serializer& serializer, Resume& self);
 
CmdResult resume(C::mip_interface& device);
 
struct GetExtendedDescriptors
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GET_EXTENDED_DESCRIPTORS;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_GET_EXTENDED_DESCRIPTORS;
        
        uint8_t descriptors_count = 0;
        uint16_t* descriptors = {nullptr};
        
    };
};
void insert(Serializer& serializer, const GetExtendedDescriptors& self);
void extract(Serializer& serializer, GetExtendedDescriptors& self);
 
void insert(Serializer& serializer, const GetExtendedDescriptors::Response& self);
void extract(Serializer& serializer, GetExtendedDescriptors::Response& self);
 
CmdResult getExtendedDescriptors(C::mip_interface& device, uint16_t* descriptorsOut, size_t descriptorsOutMax, uint8_t* descriptorsOutCount);
 
struct ContinuousBit
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_CONTINUOUS_BIT;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_CONTINUOUS_BIT;
        
        uint8_t result[16] = {0}; 
        
    };
};
void insert(Serializer& serializer, const ContinuousBit& self);
void extract(Serializer& serializer, ContinuousBit& self);
 
void insert(Serializer& serializer, const ContinuousBit::Response& self);
void extract(Serializer& serializer, ContinuousBit::Response& self);
 
CmdResult continuousBit(C::mip_interface& device, uint8_t* resultOut);
 
struct CommSpeed
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_COMM_SPEED;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = true;
    static const bool HAS_SAVE_FUNCTION = true;
    static const bool HAS_LOAD_FUNCTION = true;
    static const bool HAS_RESET_FUNCTION = true;
    
    static const uint32_t ALL_PORTS = 0;
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t port = 0; 
    uint32_t baud = 0; 
    
    struct Response
    {
        static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
        static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::REPLY_COMM_SPEED;
        
        uint8_t port = 0; 
        uint32_t baud = 0; 
        
    };
};
void insert(Serializer& serializer, const CommSpeed& self);
void extract(Serializer& serializer, CommSpeed& self);
 
void insert(Serializer& serializer, const CommSpeed::Response& self);
void extract(Serializer& serializer, CommSpeed::Response& self);
 
CmdResult writeCommSpeed(C::mip_interface& device, uint8_t port, uint32_t baud);
CmdResult readCommSpeed(C::mip_interface& device, uint8_t port, uint32_t* baudOut);
CmdResult saveCommSpeed(C::mip_interface& device, uint8_t port);
CmdResult loadCommSpeed(C::mip_interface& device, uint8_t port);
CmdResult defaultCommSpeed(C::mip_interface& device, uint8_t port);
 
struct GpsTimeUpdate
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_GPS_TIME_BROADCAST_NEW;
    
    static const bool HAS_WRITE_FUNCTION = true;
    static const bool HAS_READ_FUNCTION = false;
    static const bool HAS_SAVE_FUNCTION = false;
    static const bool HAS_LOAD_FUNCTION = false;
    static const bool HAS_RESET_FUNCTION = false;
    
    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; 
    
};
void insert(Serializer& serializer, const GpsTimeUpdate& self);
void extract(Serializer& serializer, GpsTimeUpdate& self);
 
CmdResult writeGpsTimeUpdate(C::mip_interface& device, GpsTimeUpdate::FieldId fieldId, uint32_t value);
 
struct SoftReset
{
    static const uint8_t DESCRIPTOR_SET = ::mip::commands_base::DESCRIPTOR_SET;
    static const uint8_t FIELD_DESCRIPTOR = ::mip::commands_base::CMD_SOFT_RESET;
    
    static const bool HAS_FUNCTION_SELECTOR = false;
    
    
};
void insert(Serializer& serializer, const SoftReset& self);
void extract(Serializer& serializer, SoftReset& self);
 
CmdResult softReset(C::mip_interface& device);
 
} // namespace commands_base
} // namespace mip