Class TrossenArmDriver

Class Documentation

class TrossenArmDriver

Trossen Arm Driver.

Public Functions

TrossenArmDriver()

Construct the Trossen Arm Driver object.

~TrossenArmDriver()

Destroy the Trossen Arm Driver object.

void configure(Model model, EndEffector end_effector, const std::string serv_ip, bool clear_error, double timeout = 20.0)

Configure the driver.

Parameters:

  • model – Model of the robot

  • end_effector – End effector properties

  • serv_ip – IP address of the robot

  • clear_error – Whether to clear the error state of the robot

  • timeout – Timeout for connection to the arm controller’s TCP server in seconds, default is 20.0s

void cleanup(bool reboot_controller = false)

Cleanup the driver.

Parameters:

reboot_controller – Whether to reboot the controller

inline void reboot_controller()

Reboot the controller and cleanup the driver.

Note

This function is a wrapper for cleanup(true)

void set_all_positions(const std::vector<double> &goal_positions, double goal_time = 2.0, bool blocking = true, const std::optional<std::vector<double>> &goal_feedforward_velocities = std::nullopt, const std::optional<std::vector<double>> &goal_feedforward_accelerations = std::nullopt)

Set the positions of all joints.

Note

The size of the vectors should be equal to the number of joints

Parameters:

  • goal_positions – Positions in rad for arm joints and m for the gripper joint

  • goal_time – Optional: goal time in s when the goal positions should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal positions are reached, default true

  • goal_feedforward_velocities – Optional: feedforward velocities in rad/s for arm joints and m/s for the gripper joint, default zeros

  • goal_feedforward_accelerations – Optional: feedforward accelerations in rad/s^2 for arm joints and m/s^2 for the gripper joint, default zeros

void set_arm_positions(const std::vector<double> &goal_positions, double goal_time = 2.0, bool blocking = true, const std::optional<std::vector<double>> &goal_feedforward_velocities = std::nullopt, const std::optional<std::vector<double>> &goal_feedforward_accelerations = std::nullopt)

Set the positions of the arm joints.

Note

The size of the vectors should be equal to the number of arm joints

Parameters:

  • goal_positions – Positions in rad

  • goal_time – Optional: goal time in s when the goal positions should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal positions are reached, default true

  • goal_feedforward_velocities – Optional: feedforward velocities in rad/s, default zeros

  • goal_feedforward_accelerations – Optional: feedforward accelerations in rad/s^2, default zeros

void set_gripper_position(double goal_position, double goal_time = 2.0, bool blocking = true, double goal_feedforward_velocity = 0.0, double goal_feedforward_acceleration = 0.0)

Set the position of the gripper.

Parameters:

  • goal_position – Position in m

  • goal_time – Optional: goal time in s when the goal position should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal position is reached, default true

  • goal_feedforward_velocity – Optional: feedforward velocity in m/s, default zero

  • goal_feedforward_acceleration – Optional: feedforward acceleration in m/s^2, default zero

void set_joint_position(uint8_t joint_index, double goal_position, double goal_time = 2.0, bool blocking = true, double goal_feedforward_velocity = 0.0, double goal_feedforward_acceleration = 0.0)

Set the position of a joint.

Parameters:

  • joint_index – The index of the joint in [0, num_joints - 1]

  • goal_position – Position in rad for arm joints and m for the gripper joint

  • goal_time – Optional: goal time in s when the goal position should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal position is reached, default true

  • goal_feedforward_velocity – Optional: feedforward velocity in rad/s for arm joints and m/s for the gripper joint, default zero

  • goal_feedforward_acceleration – Optional: feedforward acceleration in rad/s^2 for arm joints and m/s^2 for the gripper joint, default zero

void set_cartesian_positions(const std::array<double, 6> &goal_positions, InterpolationSpace interpolation_space, double goal_time = 2.0, bool blocking = true, const std::optional<std::array<double, 6>> &goal_feedforward_velocities = std::nullopt, const std::optional<std::array<double, 6>> &goal_feedforward_accelerations = std::nullopt, int num_trajectory_check_samples = 1000)

Set the position of the end effector in Cartesian space.

Note

The first 3 elements of goal_positions are the translation and the last 3 elements are the angle-axis representation of the rotation

Note

The first 3 elements of goal_feedforward_velocities are the linear velocity and the last 3 elements are the angular velocity

Note

The first 3 elements of goal_feedforward_accelerations are the linear acceleration and the last 3 elements are the angular acceleration

Parameters:

  • goal_positions – Spatial position of the end effector frame measured in the base frame in m and rad

  • interpolation_space – Interpolation space, one of InterpolationSpace::joint or InterpolationSpace::cartesian

  • goal_time – Optional: goal time in s when the goal positions should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal positions are reached, default true

  • goal_feedforward_velocities – Optional: spatial velocity of the end effector frame with respect to the base frame measured in the base frame in m/s and rad/s, default zeros

  • goal_feedforward_accelerations – Optional: spatial acceleration of the end effector frame with respect to the base frame measured in the base frame in m/s^2 and rad/s^2, default zeros

  • num_trajectory_check_samples – Optional: number of evenly spaced sampled time steps to check trajectory feasibility, default 1000

void set_all_velocities(const std::vector<double> &goal_velocities, double goal_time = 2.0, bool blocking = true, const std::optional<std::vector<double>> &goal_feedforward_accelerations = std::nullopt)

Set the velocities of all joints.

Note

The size of the vectors should be equal to the number of joints

Parameters:

  • goal_velocities – Velocities in rad/s for arm joints and m/s for the gripper joint

  • goal_time – Optional: goal time in s when the goal velocities should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal velocities are reached, default true

  • goal_feedforward_accelerations – Optional: feedforward accelerations in rad/s^2 for arm joints and m/s^2 for the gripper joint, default zeros

void set_arm_velocities(const std::vector<double> &goal_velocities, double goal_time = 2.0, bool blocking = true, const std::optional<std::vector<double>> &goal_feedforward_accelerations = std::nullopt)

Set the velocities of the arm joints.

Note

The size of the vectors should be equal to the number of arm joints

Parameters:

  • goal_velocities – Velocities in rad

  • blocking – Optional: whether to block until the goal velocities are reached, default true

  • goal_time – Optional: goal time in s when the goal velocities should be reached, default 2.0s

  • goal_feedforward_accelerations – Optional: feedforward accelerations in rad/s^2, default zeros

void set_gripper_velocity(double goal_velocity, double goal_time = 2.0, bool blocking = true, double goal_feedforward_acceleration = 0.0)

Set the velocity of the gripper.

Parameters:

  • goal_velocity – Velocity in m/s

  • goal_time – Optional: goal time in s when the goal velocity should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal velocity is reached, default true

  • goal_feedforward_acceleration – Optional: feedforward acceleration in m/s^2, default zero

void set_joint_velocity(uint8_t joint_index, double goal_velocity, double goal_time = 2.0, bool blocking = true, double goal_feedforward_acceleration = 0.0)

Set the velocity of a joint.

Parameters:

  • joint_index – The index of the joint in [0, num_joints - 1]

  • goal_velocity – Velocity in rad/s for arm joints and m/s for the gripper joint

  • goal_time – Optional: goal time in s when the goal velocity should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal velocity is reached, default true

  • goal_feedforward_acceleration – Optional: feedforward acceleration in rad/s^2 for arm joints and m/s^2 for the gripper joint, default zero

void set_cartesian_velocities(const std::array<double, 6> &goal_velocities, InterpolationSpace interpolation_space, double goal_time = 2.0, bool blocking = true, const std::optional<std::array<double, 6>> &goal_feedforward_accelerations = std::nullopt)

Set the velocity of the end effector in Cartesian space.

Note

The first 3 elements of goal_velocities are the linear velocity and the last 3 elements are the angular velocity

Note

The first 3 elements of goal_feedforward_accelerations are the linear acceleration and the last 3 elements are the angular acceleration

Parameters:

  • goal_velocities – Spatial velocity of the end effector frame with respect to the base frame measured in the base frame in m/s and rad/s

  • interpolation_space – Interpolation space, one of InterpolationSpace::joint or InterpolationSpace::cartesian

  • goal_time – Optional: goal time in s when the goal velocities should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal velocities are reached, default true

  • goal_feedforward_accelerations – Optional: spatial acceleration of the end effector frame with respect to the base frame measured in the base frame in m/s^2 and rad/s^2, default zeros

void set_all_external_efforts(const std::vector<double> &goal_external_efforts, double goal_time = 2.0, bool blocking = true)

Set the external efforts of all joints.

Note

The size of the vectors should be equal to the number of joints

Parameters:

  • goal_external_efforts – External efforts in Nm for arm joints and N for the gripper joint

  • goal_time – Optional: goal time in s when the goal external efforts should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal external efforts are reached, default true

void set_arm_external_efforts(const std::vector<double> &goal_external_efforts, double goal_time = 2.0, bool blocking = true)

Set the external efforts of the arm joints.

Note

The size of the vectors should be equal to the number of arm joints

Parameters:

  • goal_external_efforts – External efforts in Nm

  • goal_time – Optional: goal time in s when the goal external efforts should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal external efforts are reached, default true

void set_gripper_external_effort(double goal_external_effort, double goal_time = 2.0, bool blocking = true)

Set the external effort of the gripper.

Parameters:

  • goal_external_effort – External effort in N

  • goal_time – Optional: goal time in s when the goal external effort should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal external effort is reached, default true

void set_joint_external_effort(uint8_t joint_index, double goal_external_effort, double goal_time = 2.0, bool blocking = true)

Set the external effort of a joint.

Parameters:

  • joint_index – The index of the joint in [0, num_joints - 1]

  • goal_external_effort – External effort in Nm for arm joints and N for the gripper joint

  • goal_time – Optional: goal time in s when the goal external effort should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal external effort is reached, default true

void set_cartesian_external_efforts(const std::array<double, 6> &goal_external_efforts, InterpolationSpace interpolation_space, double goal_time = 2.0, bool blocking = true)

Set the external efforts of the end effector in Cartesian space.

Note

The first 3 elements of goal_external_efforts are the force and the last 3 elements are the torque

Parameters:

  • goal_external_efforts – Spatial external efforts applied to the end effector frame measured in the base frame in N and Nm

  • interpolation_space – Interpolation space, one of InterpolationSpace::joint or InterpolationSpace::cartesian

  • goal_time – Optional: goal time in s when the goal external efforts should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal external efforts are reached, default true

void set_all_efforts(const std::vector<double> &goal_efforts, double goal_time = 2.0, bool blocking = true)

Set the efforts of all joints.

Note

The size of the vectors should be equal to the number of joints

Parameters:

  • goal_efforts – Efforts in Nm for arm joints and N for the gripper joint

  • goal_time – Optional: goal time in s when the goal efforts should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal efforts are reached, default true

void set_arm_efforts(const std::vector<double> &goal_efforts, double goal_time = 2.0, bool blocking = true)

Set the efforts of the arm joints.

Note

The size of the vectors should be equal to the number of arm joints

Parameters:

  • goal_efforts – Efforts in Nm

  • goal_time – Optional: goal time in s when the goal efforts should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal efforts are reached, default true

void set_gripper_effort(double goal_effort, double goal_time = 2.0, bool blocking = true)

Set the effort of the gripper.

Parameters:

  • goal_effort – Effort in N

  • goal_time – Optional: goal time in s when the goal effort should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal effort is reached, default true

void set_joint_effort(uint8_t joint_index, double goal_effort, double goal_time = 2.0, bool blocking = true)

Set the effort of a joint.

Parameters:

  • joint_index – The index of the joint in [0, num_joints - 1]

  • goal_effort – Effort in Nm for arm joints and N for the gripper joint

  • goal_time – Optional: goal time in s when the goal effort should be reached, default 2.0s

  • blocking – Optional: whether to block until the goal effort is reached, default true

void load_configs_from_file(const std::string &file_path)

Load configurations from a YAML file and set them.

Parameters:

file_path – The file path to load the configurations

void set_factory_reset_flag(bool flag = true)

Set the factory reset flag.

Parameters:

flag – Whether to reset the configurations to factory defaults at the next startup

void set_ip_method(IPMethod method = IPMethod::manual)

Set the IP method.

Parameters:

method – The IP method to set, one of IPMethod::manual or IPMethod::dhcp

void set_manual_ip(const std::string manual_ip = "192.168.1.2")

Set the manual IP.

Parameters:

manual_ip – The manual IP address to set

void set_dns(const std::string dns = "8.8.8.8")

Set the DNS.

Parameters:

dns – The DNS to set

void set_gateway(const std::string gateway = "192.168.1.1")

Set the gateway.

Parameters:

gateway – The gateway to set

void set_subnet(const std::string subnet = "255.255.255.0")

Set the subnet.

Parameters:

subnet – The subnet to set

void set_joint_characteristics(const std::vector<JointCharacteristic> &joint_characteristics)

Set the joint characteristics.

  • effort_correction: [0.2, 5.0]

  • friction_transition_velocity: positive

Note

The size of the vector should be equal to the number of joints

Note

Some joint characteristics are required to be within the following ranges

Parameters:

joint_characteristics – Joint characteristics

void set_effort_corrections(const std::vector<double> &effort_corrections)

Set the effort corrections.

Note

This configuration is used to map the efforts in Nm or N to the motor effort unit, i.e., effort_correction = motor effort unit / Nm or N

Note

The size of the vector should be equal to the number of joints

Note

Each element in the vector should be within the range [0.2, 5.0]

Parameters:

effort_corrections – Effort corrections in motor effort unit / Nm or N

void set_friction_transition_velocities(const std::vector<double> &friction_transition_velocities)

Set the friction transition velocities.

Note

The size of the vector should be equal to the number of joints

Note

Each element in the vector should be positive

Parameters:

friction_transition_velocities – Friction transition velocities in rad/s for arm joints and m/s for the gripper joint

void set_friction_constant_terms(const std::vector<double> &friction_constant_terms)

Set the friction constant terms.

Note

The size of the vector should be equal to the number of joints

Parameters:

friction_constant_terms – Friction constant terms in Nm for arm joints and N for the gripper joint

void set_friction_coulomb_coefs(const std::vector<double> &friction_coulomb_coefs)

Set the friction coulomb coefs.

Note

The size of the vector should be equal to the number of joints

Parameters:

friction_coulomb_coefs – Friction coulomb coefs in Nm/Nm for arm joints and N/N for the gripper joint

void set_friction_viscous_coefs(const std::vector<double> &friction_viscous_coefs)

Set the friction viscous coefs.

Note

The size of the vector should be equal to the number of joints

Parameters:

friction_viscous_coefs – Friction viscous coefs in Nm/(rad/s) for arm joints and N/(m/s) for the gripper joint

void set_position_offsets(const std::vector<double> &position_offsets)

Set the position offsets.

Note

The size of the vector should be equal to the number of joints

Parameters:

position_offsets – Position offsets in rad for arm joints and m for the gripper joint

void set_joint_modes(const std::vector<Mode> &modes)

Set the modes of each joint.

  • Mode::idle

  • Mode::position

  • Mode::velocity

  • Mode::external_effort

  • Mode::effort

Note

The size of the vector should be equal to the number of joints

Parameters:

modes – Desired modes for each joint, one of

void set_all_modes(Mode mode = Mode::idle)

Set all joints to the same mode.

  • Mode::idle

  • Mode::position

  • Mode::velocity

  • Mode::external_effort

  • Mode::effort

Parameters:

mode – Desired mode for all joints, one of

void set_arm_modes(Mode mode = Mode::idle)

Set the mode of the arm joints.

  • Mode::idle

  • Mode::position

  • Mode::velocity

  • Mode::external_effort

  • Mode::effort

Warning

This method does not change the gripper joint’s mode

Parameters:

mode – Desired mode for the arm joints, one of

void set_gripper_mode(Mode mode = Mode::idle)

Set the mode of the gripper joint.

  • Mode::idle

  • Mode::position

  • Mode::velocity

  • Mode::external_effort

  • Mode::effort

Warning

This method does not change the arm joints’ mode

Parameters:

mode – Desired mode for the gripper joint, one of

void set_end_effector(const EndEffector &end_effector)

Set the end effector properties.

Parameters:

end_effector – The end effector properties

void set_joint_limits(const std::vector<JointLimit> &joint_limits)

Set the joint limits.

Parameters:

joint_limits – Joint limits of all joints

void set_motor_parameters(const std::vector<std::map<Mode, MotorParameter>> &motor_parameters)

Set the motor parameters.

Parameters:

motor_parameters – Motor parameters of all modes of all joints

void set_algorithm_parameter(const AlgorithmParameter &algorithm_parameter)

Set the algorithm parameter.

Parameters:

algorithm_parameter – Parameter used for robotic algorithms

uint8_t get_num_joints() const

Get the number of joints.

Returns:

Number of joints

const std::string &get_driver_version() const

Get driver version.

Returns:

Driver version

const std::string &get_controller_version() const

Get controller firmware version.

Returns:

Controller firmware version

const RobotOutput &get_robot_output()

Get the robot output.

Returns:

Robot output

const std::vector<double> &get_positions()

Get the positions.

Returns:

Positions in rad for arm joints and m for the gripper joint

const std::vector<double> &get_all_positions()

Get the positions of all joints.

Returns:

Positions in rad for arm joints and m for the gripper joint

const std::vector<double> &get_arm_positions()

Get the positions of the arm joints.

Returns:

Positions in rad

double get_gripper_position()

Get the position of the gripper.

Returns:

Position in m

double get_joint_position(uint8_t joint_index)

Get the position of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Position in rad for arm joints and m for the gripper joint

const std::array<double, 6> &get_cartesian_positions()

Get the Cartesian positions.

Note

The first 3 elements are the translation and the last 3 elements are the angle-axis representation of the rotation

Returns:

Spatial position of the end effector frame measured in the base frame in m and rad

const std::vector<double> &get_velocities()

Get the velocities.

Returns:

Velocities in rad/s for arm joints and m/s for the gripper joint

const std::vector<double> &get_all_velocities()

Get the velocities of all joints.

Returns:

Velocities in rad/s for arm joints and m/s for the gripper joint

const std::vector<double> &get_arm_velocities()

Get the velocities of the arm joints.

Returns:

Velocities in rad/s

double get_gripper_velocity()

Get the velocity of the gripper.

Returns:

Velocity in m/s

double get_joint_velocity(uint8_t joint_index)

Get the velocity of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Velocity in rad/s for arm joints and m/s for the gripper joint

const std::array<double, 6> &get_cartesian_velocities()

Get the Cartesian velocities.

Note

The first 3 elements are the linear velocity and the last 3 elements are the angular velocity

Returns:

Spatial velocity of the end effector frame with respect to the base frame measured in the base frame in m/s and rad/s

const std::vector<double> &get_all_accelerations()

Get the accelerations.

Returns:

Accelerations in rad/s^2 for arm joints and m/s^2 for the gripper joint

const std::vector<double> &get_arm_accelerations()

Get the accelerations of all joints.

Returns:

Accelerations in rad/s^2 for arm joints and m/s^2 for the gripper joint

double get_gripper_acceleration()

Get the acceleration of the gripper.

Returns:

Acceleration in m/s^2

double get_joint_acceleration(uint8_t joint_index)

Get the acceleration of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Acceleration in rad/s^2 for arm joints and m/s^2 for the gripper joint

const std::array<double, 6> &get_cartesian_accelerations()

Get the Cartesian accelerations.

Note

The first 3 elements are the linear acceleration and the last 3 elements are the angular acceleration

Returns:

Spatial acceleration of the end effector frame with respect to the base frame measured in the base frame in m/s^2 and rad/s^2

const std::vector<double> &get_efforts()

Get the efforts.

Returns:

Efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_all_efforts()

Get the efforts of all joints.

Returns:

Efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_arm_efforts()

Get the efforts of the arm joints.

Returns:

Efforts in Nm

double get_gripper_effort()

Get the effort of the gripper.

Returns:

Effort in N

double get_joint_effort(uint8_t joint_index)

Get the effort of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Effort in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_external_efforts()

Get the external efforts.

Returns:

External efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_all_external_efforts()

Get the external efforts of all joints.

Returns:

External efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_arm_external_efforts()

Get the external efforts of the arm joints.

Returns:

External efforts in Nm

double get_gripper_external_effort()

Get the external effort of the gripper.

Returns:

External effort in N

double get_joint_external_effort(uint8_t joint_index)

Get the external effort of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

External effort in Nm for arm joints and N for the gripper joint

const std::array<double, 6> &get_cartesian_external_efforts()

Get the compensation efforts.

Note

The first 3 elements are the force and the last 3 elements are the torque

Returns:

Spatial external efforts applied to the end effector frame measured in the base frame in N and Nm

const std::vector<double> &get_compensation_efforts()

Get the compensation efforts.

Returns:

Compensation efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_all_compensation_efforts()

Get the compensation efforts of all joints.

Returns:

Compensation efforts in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_arm_compensation_efforts()

Get the compensation efforts of the arm joints.

Returns:

Compensation efforts in Nm

double get_gripper_compensation_effort()

Get the compensation effort of the gripper.

Returns:

Compensation effort in N

double get_joint_compensation_effort(uint8_t joint_index)

Get the compensation effort of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Compensation effort in Nm for arm joints and N for the gripper joint

const std::vector<double> &get_all_rotor_temperatures()

Get the rotor temperatures of all joints.

Returns:

Rotor temperatures in C

const std::vector<double> &get_arm_rotor_temperatures()

Get the rotor temperatures of the arm joints.

Returns:

Rotor temperatures in C

double get_gripper_rotor_temperature()

Get the rotor temperature of the gripper.

Returns:

Rotor temperature in C

double get_joint_rotor_temperature(uint8_t joint_index)

Get the rotor temperature of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Rotor temperature in C

const std::vector<double> &get_all_driver_temperatures()

Get the driver temperatures of all joints.

Returns:

Driver temperatures in C

const std::vector<double> &get_arm_driver_temperatures()

Get the driver temperatures of the arm joints.

Returns:

Driver temperatures in C

double get_gripper_driver_temperature()

Get the driver temperature of the gripper.

Returns:

Driver temperature in C

double get_joint_driver_temperature(uint8_t joint_index)

Get the driver temperature of a joint.

Parameters:

joint_index – The index of the joint in [0, num_joints - 1]

Returns:

Driver temperature in C

void save_configs_to_file(const std::string &file_path)

Save configurations to a YAML file.

Parameters:

file_path – The file path to store the configurations

bool get_factory_reset_flag()

Get the factory reset flag.

Returns:

true The configurations will be reset to factory defaults at the next startup

Returns:

false The configurations will not be reset to factory defaults at the next startup

IPMethod get_ip_method()

Get the IP method.

Returns:

The IP method of the robot

std::string get_manual_ip()

Get the manual IP.

Returns:

Manual IP address

std::string get_dns()

Get the DNS.

Returns:

DNS address

std::string get_gateway()

Get the gateway.

Returns:

Gateway address

std::string get_subnet()

Get the subnet.

Returns:

Subnet address

std::vector<JointCharacteristic> get_joint_characteristics()

Get the joint characteristics.

Returns:

Joint characteristics

std::vector<double> get_effort_corrections()

Get the effort corrections.

Returns:

Effort corrections in motor effort unit / Nm or N

std::vector<double> get_friction_transition_velocities()

Get the friction transition velocities.

Returns:

Friction transition velocities in rad/s for arm joints and m/s for the gripper joint

std::vector<double> get_friction_constant_terms()

Get the friction constant terms.

Returns:

Friction constant terms in Nm for arm joints and N for the gripper joint

std::vector<double> get_friction_coulomb_coefs()

Get the friction coulomb coefs.

Returns:

Friction coulomb coefs in Nm/Nm for arm joints and N/N for the gripper joint

std::vector<double> get_friction_viscous_coefs()

Get the friction viscous coefs.

Returns:

Friction viscous coefs in Nm/(rad/s) for arm joints and N/(m/s) for the gripper joint

std::vector<double> get_position_offsets()

Get the position offsets.

Returns:

Position offsets in rad for arm joints and m for the gripper joint

std::string get_error_information()

Get the error information of the robot.

Returns:

Error information

std::vector<Mode> get_modes()

Get the modes.

Returns:

Modes of all joints, a vector of Modes

EndEffector get_end_effector()

Get the end effector properties.

Returns:

The end effector properties

std::vector<JointLimit> get_joint_limits()

Get the joint limits.

Returns:

Joint limits of all joints

std::vector<std::map<Mode, MotorParameter>> get_motor_parameters()

Get the motor parameters.

Returns:

Motor parameters of all modes of all joints

AlgorithmParameter get_algorithm_parameter()

Get the algorithm parameter.

Returns:

Parameter used for robotic algorithms

bool get_is_configured()

Get the configured status of the robot.

Returns:

true The robot is configured

Returns:

false The robot is not configured

Public Static Functions

static std::string get_logger_name(Model model, const std::string &serv_ip)

Get the logger name.

Parameters:

  • model – Model of the robot

  • serv_ip – IP address of the robot

Returns:

Logger name

static std::string get_default_logger_name()

Get the default logger name.

Returns:

Default logger name