commands_system.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_system {
 
 
// Descriptors
 
enum 
{
    DESCRIPTOR_SET           = 0x7F,
    
    CMD_ENUMERATE            = 0x01,
    CMD_INTERFACE_CONTROL    = 0x02,
    CMD_COM_MODE             = 0x10,
    CMD_HARDWARE_CONTROL     = 0x11,
    CMD_HARDWARE_CONTROL_2   = 0x12,
    
    REPLY_COM_MODE           = 0x90,
    REPLY_HARDWARE_CONTROL   = 0x91,
    REPLY_HARDWARE_CONTROL_2 = 0x92,
    REPLY_INTERFACE_CONTROL  = 0x82,
};
 
// Shared Type Definitions
 
static constexpr const uint8_t MIP_SYSTEM_COMMAND_COMM_MODE_PASSTHRU = 0x00;
static constexpr const uint8_t MIP_SYSTEM_COMMAND_COMM_MODE_NORMAL = 0x01;
static constexpr const uint8_t MIP_SYSTEM_COMMAND_COMM_MODE_IMU = 0x02;
static constexpr const uint8_t MIP_SYSTEM_COMMAND_COMM_MODE_GPS = 0x03;
enum class CommsInterface : uint8_t
{
    ALL    = 0,  
    MAIN   = 1,  
    UART_1 = 17,  
    UART_2 = 18,  
    UART_3 = 19,  
    USB_1  = 33,  
    USB_2  = 34,  
};
 
struct CommsProtocol : Bitfield<CommsProtocol>
{
    typedef uint32_t Type;
    enum _enumType : uint32_t
    {
        NONE         = 0x00000000,
        MIP_COMMANDS = 0x00000001,  
        MIP_DATA     = 0x00000002,  
        NMEA         = 0x00000004,  
        RTCM         = 0x00000008,  
        SPARTN       = 0x00000010,  
        ALL          = 0x0000001F,
    };
    uint32_t value = NONE;
    
    CommsProtocol() : value(NONE) {}
    CommsProtocol(int val) : value((uint32_t)val) {}
    operator uint32_t() const { return value; }
    CommsProtocol& operator=(uint32_t val) { value = val; return *this; }
    CommsProtocol& operator=(int val) { value = uint32_t(val); return *this; }
    CommsProtocol& operator|=(uint32_t val) { return *this = value | val; }
    CommsProtocol& operator&=(uint32_t val) { return *this = value & val; }
    
    bool mipCommands() const { return (value & MIP_COMMANDS) > 0; }
    void mipCommands(bool val) { value &= ~MIP_COMMANDS; if(val) value |= MIP_COMMANDS; }
    bool mipData() const { return (value & MIP_DATA) > 0; }
    void mipData(bool val) { value &= ~MIP_DATA; if(val) value |= MIP_DATA; }
    bool nmea() const { return (value & NMEA) > 0; }
    void nmea(bool val) { value &= ~NMEA; if(val) value |= NMEA; }
    bool rtcm() const { return (value & RTCM) > 0; }
    void rtcm(bool val) { value &= ~RTCM; if(val) value |= RTCM; }
    bool spartn() const { return (value & SPARTN) > 0; }
    void spartn(bool val) { value &= ~SPARTN; if(val) value |= SPARTN; }
    bool allSet() const { return value == ALL; }
    void setAll() { value |= ALL; }
};
 
// Mip Fields
 
 
struct CommMode
{
    FunctionSelector function = static_cast<FunctionSelector>(0);
    uint8_t mode = 0;
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_system::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_system::CMD_COM_MODE;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "CommMode";
    static constexpr const char* DOC_NAME = "CommMode";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(mode);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(mode));
    }
    
    static CommMode create_sld_all(::mip::FunctionSelector function)
    {
        CommMode cmd;
        cmd.function = function;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        uint8_t mode = 0;
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_system::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_system::REPLY_COM_MODE;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "CommMode::Response";
        static constexpr const char* DOC_NAME = "CommMode Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(mode);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(mode));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<CommMode> writeCommMode(C::mip_interface& device, uint8_t mode);
TypedResult<CommMode> readCommMode(C::mip_interface& device, uint8_t* modeOut);
TypedResult<CommMode> defaultCommMode(C::mip_interface& device);
 
 
struct InterfaceControl
{
    FunctionSelector function = static_cast<FunctionSelector>(0);
    CommsInterface port = static_cast<CommsInterface>(0); 
    CommsProtocol protocols_incoming; 
    CommsProtocol protocols_outgoing; 
    
    static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_system::DESCRIPTOR_SET;
    static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_system::CMD_INTERFACE_CONTROL;
    static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
    static constexpr const char* NAME = "InterfaceControl";
    static constexpr const char* DOC_NAME = "Interface Control";
    static constexpr const bool HAS_FUNCTION_SELECTOR = true;
    
    auto asTuple() const
    {
        return std::make_tuple(port,protocols_incoming,protocols_outgoing);
    }
    
    auto asTuple()
    {
        return std::make_tuple(std::ref(port),std::ref(protocols_incoming),std::ref(protocols_outgoing));
    }
    
    static InterfaceControl create_sld_all(::mip::FunctionSelector function)
    {
        InterfaceControl cmd;
        cmd.function = function;
        cmd.port = ::mip::commands_system::CommsInterface::ALL;
        return cmd;
    }
    
    void insert(Serializer& serializer) const;
    void extract(Serializer& serializer);
    
    struct Response
    {
        CommsInterface port = static_cast<CommsInterface>(0); 
        CommsProtocol protocols_incoming; 
        CommsProtocol protocols_outgoing; 
        
        static constexpr const uint8_t DESCRIPTOR_SET = ::mip::commands_system::DESCRIPTOR_SET;
        static constexpr const uint8_t FIELD_DESCRIPTOR = ::mip::commands_system::REPLY_INTERFACE_CONTROL;
        static constexpr const CompositeDescriptor DESCRIPTOR = {DESCRIPTOR_SET, FIELD_DESCRIPTOR};
        static constexpr const char* NAME = "InterfaceControl::Response";
        static constexpr const char* DOC_NAME = "Interface Control Response";
        static constexpr const bool HAS_FUNCTION_SELECTOR = false;
        
        auto asTuple() const
        {
            return std::make_tuple(port,protocols_incoming,protocols_outgoing);
        }
        
        auto asTuple()
        {
            return std::make_tuple(std::ref(port),std::ref(protocols_incoming),std::ref(protocols_outgoing));
        }
        
        void insert(Serializer& serializer) const;
        void extract(Serializer& serializer);
        
    };
};
TypedResult<InterfaceControl> writeInterfaceControl(C::mip_interface& device, CommsInterface port, CommsProtocol protocolsIncoming, CommsProtocol protocolsOutgoing);
TypedResult<InterfaceControl> readInterfaceControl(C::mip_interface& device, CommsInterface port, CommsProtocol* protocolsIncomingOut, CommsProtocol* protocolsOutgoingOut);
TypedResult<InterfaceControl> saveInterfaceControl(C::mip_interface& device, CommsInterface port);
TypedResult<InterfaceControl> loadInterfaceControl(C::mip_interface& device, CommsInterface port);
TypedResult<InterfaceControl> defaultInterfaceControl(C::mip_interface& device, CommsInterface port);
 
 
} // namespace commands_system
} // namespace mip