PowerCubeCtrlParams.h

Go to the documentation of this file.

#ifndef __POWER_CUBE_CTRL_PARAMS_H_
#define __POWER_CUBE_CTRL_PARAMS_H_

class PowerCubeCtrlParams
{

public:

        PowerCubeCtrlParams()
        {
                m_DOF = 0;
                m_UseMoveVel = true;
        };

        ~PowerCubeCtrlParams();

        int Init(std::string CanModule, std::string CanDevice, int Baudrate, std::vector<int> ModuleIDs)
        {
                SetCanModule(CanModule);
                SetCanDevice(CanDevice);
                SetBaudrate(Baudrate);
                SetDOF(ModuleIDs.size());
                for (int i = 0; i < m_DOF; i++)
                {
                        m_ModulIDs.push_back(ModuleIDs[i]);
                }
                return 0;
        }

        void SetDOF(int DOF)
        {
                m_DOF = DOF;
        }

        int GetDOF()
        {
                return m_DOF;
        }

        void SetUseMoveVel(bool UseMoveVel)
        {
                m_UseMoveVel = UseMoveVel;
        }

        int GetUseMoveVel()
        {
                return m_UseMoveVel;
        }

        void SetCanModule(std::string CanModule)
        {
                m_CanModule = CanModule;
        }

        std::string GetCanModule()
        {
                return m_CanModule;
        }

        void SetCanDevice(std::string CanDevice)
        {
                m_CanDevice = CanDevice;
        }

        std::string GetCanDevice()
        {
                return m_CanDevice;
        }

        void SetBaudrate(int Baudrate)
        {
                m_Baudrate = Baudrate;
        }

        int GetBaudrate()
        {
                return m_Baudrate;
        }

        std::vector<int> GetModuleIDs()
        {
                return m_ModulIDs;
        }
        
        int GetModuleID(int no)
        {
                if (no < GetDOF())
                        return m_ModulIDs[no];
                else
                        return -1;
        }
        
        int SetModuleID(int no, int id)
        {
                if (no < GetDOF())
                {
                        m_ModulIDs[no] = id;
                        return 0;
                }
                else
                        return -1;
        }

        std::vector<std::string> GetJointNames()
        {
                return m_JointNames;
        }

        int SetJointNames(std::vector<std::string> JointNames)
        {
                if ((int)JointNames.size() == GetDOF())
                {
                        m_JointNames = JointNames;
                        return 0;
                }
                else
                        return -1;
        }
        // ToDo: Check the following

        // Functions for angular constraints: //

        int SetUpperLimits(std::vector<double> UpperLimits)
        {
                if ((int)UpperLimits.size() == GetDOF())
                {
                        m_UpperLimits = UpperLimits;
                        return 0;
                }
                return -1;
        }

        int SetLowerLimits(std::vector<double> LowerLimits)
        {
                if ((int)LowerLimits.size() == GetDOF())
                {
                        m_LowerLimits = LowerLimits;
                        return 0;
                }
                return -1;
        }

        int SetOffsets(std::vector<double> AngleOffsets)
        {
                if ((int)AngleOffsets.size() == GetDOF())
                {
                        m_Offsets = AngleOffsets;
                        return 0;
                }
                return -1;
        }

        int SetMaxVel(std::vector<double> MaxVel)
        {
                if ((int)MaxVel.size() == GetDOF())
                {
                        m_MaxVel = MaxVel;
                        return 0;
                }
                return -1;
        }

        int SetMaxAcc(std::vector<double> MaxAcc)
        {
                if ((int)MaxAcc.size() == GetDOF())
                {
                        m_MaxAcc = MaxAcc;
                        return 0;
                }
                return -1;
        }

        std::vector<double> GetUpperLimits()
        {
                return m_UpperLimits;
        }

        std::vector<double> GetLowerLimits()
        {
                return m_LowerLimits;
        }

        std::vector<double> GetOffsets()
        {
                return m_Offsets;
        }

        std::vector<double> GetMaxAcc()
        {
                return m_MaxAcc;
        }

        std::vector<double> GetMaxVel()
        {
                return m_MaxVel;
        }

private:
        int m_DOF;
        std::vector<int> m_ModulIDs;
        std::vector<std::string> m_JointNames;
        std::string m_CanModule;
        std::string m_CanDevice;
        int m_Baudrate;
        bool m_UseMoveVel;
        std::vector<double> m_Offsets;
        std::vector<double> m_UpperLimits;
        std::vector<double> m_LowerLimits;
        std::vector<double> m_MaxVel;
        std::vector<double> m_MaxAcc;
};

#endif