aikido::control Namespace Reference

Namespaces
	ros

Classes
class	Executor
	Abstract class for executing commands on degrees of freedom. More...
class	InstantaneousTrajectoryExecutor
	Instantaneously executes a trajectory in simulation by setting DOF positions to the end of the trajectory. More...
class	JacobianExecutor
	Executes end-effector SE3 command. More...
class	JointCommandExecutor
	Abstract class for executing a command of a single type on a group of joints. More...
class	KinematicSimulationJointCommandExecutor
	Executes joint command in DART. More...
class	KinematicSimulationTrajectoryExecutor
	Executes trajectories in DART. More...
class	QueuedTrajectoryExecutor
	Wraps a TrajectoryExecutor to enable queuing trajectories for execution. More...
class	TrajectoryExecutor
	Abstract class for executing trajectories. More...
class	TrajectoryResult
class	TrajectoryRunningException
class	VisualServoingVelocityExecutor
	Executes end-effector R3 linear velocity command towards a perceived target Uses underlying JacobianVelocityExecutor on its own thread. More...

Typedefs
using	ExecutorPtr = std::shared_ptr< Executor >
using	ConstExecutorPtr = std::shared_ptr< const Executor >
using	WeakExecutorPtr = std::weak_ptr< Executor >
using	WeakConstExecutorPtr = std::weak_ptr< const Executor >
using	UniqueExecutorPtr = std::unique_ptr< Executor >
using	UniqueConstExecutorPtr = std::unique_ptr< const Executor >
using	JacobianVelocityExecutor = JacobianExecutor< ExecutorType::VELOCITY >
using	JacobianEffortExecutor = JacobianExecutor< ExecutorType::EFFORT >
using	PositionExecutor = JointCommandExecutor< ExecutorType::POSITION >
using	VelocityExecutor = JointCommandExecutor< ExecutorType::VELOCITY >
using	EffortExecutor = JointCommandExecutor< ExecutorType::EFFORT >
using	KinematicSimulationPositionExecutor = KinematicSimulationJointCommandExecutor< ExecutorType::POSITION >
using	KinematicSimulationVelocityExecutor = KinematicSimulationJointCommandExecutor< ExecutorType::VELOCITY >
using	KinematicSimulationEffortExecutor = KinematicSimulationJointCommandExecutor< ExecutorType::EFFORT >
using	TrajectoryExecutorPtr = std::shared_ptr< TrajectoryExecutor >
using	ConstTrajectoryExecutorPtr = std::shared_ptr< const TrajectoryExecutor >
using	WeakTrajectoryExecutorPtr = std::weak_ptr< TrajectoryExecutor >
using	WeakConstTrajectoryExecutorPtr = std::weak_ptr< const TrajectoryExecutor >
using	UniqueTrajectoryExecutorPtr = std::unique_ptr< TrajectoryExecutor >
using	UniqueConstTrajectoryExecutorPtr = std::unique_ptr< const TrajectoryExecutor >
using	TrajectoryResultPtr = std::shared_ptr< TrajectoryResult >
using	ConstTrajectoryResultPtr = std::shared_ptr< const TrajectoryResult >
using	WeakTrajectoryResultPtr = std::weak_ptr< TrajectoryResult >
using	WeakConstTrajectoryResultPtr = std::weak_ptr< const TrajectoryResult >
using	UniqueTrajectoryResultPtr = std::unique_ptr< TrajectoryResult >
using	UniqueConstTrajectoryResultPtr = std::unique_ptr< const TrajectoryResult >

Enumerations
enum	ExecutorType {   ExecutorType::STATE = 0, ExecutorType::POSITION = 1, ExecutorType::VELOCITY = 2, ExecutorType::EFFORT = 3,   ExecutorType::TRAJECTORY = 4, ExecutorType::MODE = 5, ExecutorType::READONLY = 6 }
	Type of executor Can be used to determine if 2 executors make conflicting demands of individual degrees of freedom (Dofs) Can also be used to gracefully dynamic_cast Roughly analogous to default ROS control types: https://wiki.ros.org/ros_control The following updates the state of the DoF directly: STATE The following do not necessarily update the DoF's state directly, but may require locking external resources: POSITION - commands position to dofs VELOCITY - commands velocity to dofs EFFORT - commands effort (i.e. More...

Functions
std::vector< std::string >	skeletonToDofNames (dart::dynamics::ConstMetaSkeletonPtr skeleton)
	Get joint names from skeleton for Executor intiialization. More...
std::set< ExecutorType >	concatenateTypes (std::set< ExecutorType > first, std::set< ExecutorType > second)
	Concatenate two sets of ExecutorTypes Useful for initializer-list constructors. More...
template<typename T >
T	checkNull (T obj)
	Check if Ptr is null Useful for initializer Lists. More...

Variables
constexpr std::chrono::milliseconds	defaultThreadRate {10}
	Default rate for ExecutorThread to call step() More...

Typedef Documentation

ConstExecutorPtr

using aikido::control::ConstExecutorPtr = typedef std::shared_ptr< const Executor >

ConstTrajectoryExecutorPtr

using aikido::control::ConstTrajectoryExecutorPtr = typedef std::shared_ptr< const TrajectoryExecutor >

ConstTrajectoryResultPtr

using aikido::control::ConstTrajectoryResultPtr = typedef std::shared_ptr< const TrajectoryResult >

EffortExecutor

using aikido::control::EffortExecutor = typedef JointCommandExecutor<ExecutorType::EFFORT>

ExecutorPtr

using aikido::control::ExecutorPtr = typedef std::shared_ptr< Executor >

JacobianEffortExecutor

using aikido::control::JacobianEffortExecutor = typedef JacobianExecutor<ExecutorType::EFFORT>

JacobianVelocityExecutor

using aikido::control::JacobianVelocityExecutor = typedef JacobianExecutor<ExecutorType::VELOCITY>

KinematicSimulationEffortExecutor

using aikido::control::KinematicSimulationEffortExecutor = typedef KinematicSimulationJointCommandExecutor<ExecutorType::EFFORT>

KinematicSimulationPositionExecutor

using aikido::control::KinematicSimulationPositionExecutor = typedef KinematicSimulationJointCommandExecutor<ExecutorType::POSITION>

KinematicSimulationVelocityExecutor

using aikido::control::KinematicSimulationVelocityExecutor = typedef KinematicSimulationJointCommandExecutor<ExecutorType::VELOCITY>

PositionExecutor

using aikido::control::PositionExecutor = typedef JointCommandExecutor<ExecutorType::POSITION>

TrajectoryExecutorPtr

using aikido::control::TrajectoryExecutorPtr = typedef std::shared_ptr< TrajectoryExecutor >

TrajectoryResultPtr

using aikido::control::TrajectoryResultPtr = typedef std::shared_ptr< TrajectoryResult >

UniqueConstExecutorPtr

using aikido::control::UniqueConstExecutorPtr = typedef std::unique_ptr< const Executor >

UniqueConstTrajectoryExecutorPtr

using aikido::control::UniqueConstTrajectoryExecutorPtr = typedef std::unique_ptr< const TrajectoryExecutor >

UniqueConstTrajectoryResultPtr

using aikido::control::UniqueConstTrajectoryResultPtr = typedef std::unique_ptr< const TrajectoryResult >

UniqueExecutorPtr

using aikido::control::UniqueExecutorPtr = typedef std::unique_ptr< Executor >

UniqueTrajectoryExecutorPtr

using aikido::control::UniqueTrajectoryExecutorPtr = typedef std::unique_ptr< TrajectoryExecutor >

UniqueTrajectoryResultPtr

using aikido::control::UniqueTrajectoryResultPtr = typedef std::unique_ptr< TrajectoryResult >

VelocityExecutor

using aikido::control::VelocityExecutor = typedef JointCommandExecutor<ExecutorType::VELOCITY>

WeakConstExecutorPtr

using aikido::control::WeakConstExecutorPtr = typedef std::weak_ptr< const Executor >

WeakConstTrajectoryExecutorPtr

using aikido::control::WeakConstTrajectoryExecutorPtr = typedef std::weak_ptr< const TrajectoryExecutor >

WeakConstTrajectoryResultPtr

using aikido::control::WeakConstTrajectoryResultPtr = typedef std::weak_ptr< const TrajectoryResult >

WeakExecutorPtr

using aikido::control::WeakExecutorPtr = typedef std::weak_ptr< Executor >

WeakTrajectoryExecutorPtr

using aikido::control::WeakTrajectoryExecutorPtr = typedef std::weak_ptr< TrajectoryExecutor >

WeakTrajectoryResultPtr

using aikido::control::WeakTrajectoryResultPtr = typedef std::weak_ptr< TrajectoryResult >

Enumeration Type Documentation

ExecutorType

enum aikido::control::ExecutorType

strong

Type of executor Can be used to determine if 2 executors make conflicting demands of individual degrees of freedom (Dofs) Can also be used to gracefully dynamic_cast Roughly analogous to default ROS control types: https://wiki.ros.org/ros_control The following updates the state of the DoF directly: STATE The following do not necessarily update the DoF's state directly, but may require locking external resources: POSITION - commands position to dofs VELOCITY - commands velocity to dofs EFFORT - commands effort (i.e.

torque) to dofs TRAJECTORY - commands a trajectory to dofs MODE - commands a hardware command mode (e.g. position/velocity/effort) The following doesn't update the DoF directly: READONLY

Enumerator
STATE
POSITION
VELOCITY
EFFORT
TRAJECTORY
MODE
READONLY

Function Documentation

checkNull()

template<typename T >

T aikido::control::checkNull ( T  obj )

inline

Check if Ptr is null Useful for initializer Lists.

concatenateTypes()

std::set<ExecutorType> aikido::control::concatenateTypes ( std::set< ExecutorType >  first, std::set< ExecutorType >  second  )

inline

Concatenate two sets of ExecutorTypes Useful for initializer-list constructors.

skeletonToDofNames()

std::vector<std::string> aikido::control::skeletonToDofNames ( dart::dynamics::ConstMetaSkeletonPtr  skeleton )

inline

Get joint names from skeleton for Executor intiialization.

Variable Documentation

defaultThreadRate

constexpr std::chrono::milliseconds aikido::control::defaultThreadRate {10}

constexpr

Default rate for ExecutorThread to call step()