---

OSCAR Namespace Reference

OSCAR is the namespace for all of OSCAR. More...

Compounds
class	AbsPosMC
class	ArmMC
class	Array
class	Array< Type >
	This class is a generic template array class. More...
class	ArtificialPotentialF
	A function to calculate artificial potential field (APF). More...
class	ATISensor
	Derived class for ATI Force/Torque sensors. This class is derived from the abstract template class Sensor<Type>. Since this class is used to sense 6D end-effector force vectors accompanied by an error state, Sensor<Type> is customized to Sensor<Vector7> Note: This implementation of the ATI F/T sensor interfaces through the serial port. However, it can interface through DAQ too. The sensor controller supports tool transformations, temperature compensation, biasing, and a variety of error checking. More...
class	Base
	Acts as the base class for all OSCAR classes. More...
class	BaseController
class	BezierCurve
	This class can be used to generate Bezier Curves from provided control points. A Bezier Curve will interpolate the starting and end points and will stay within the convex hull of the control points. More...
class	Bit3IO
class	Box
	A box obstacle used for modeling of objects in workcells. More...
class	BoxData
	Reads and writes a Box to and from an XML data file. More...
class	BSpline
	This class can be used to generate B-Spline curves. B-Splines are an advanced curve form that allows for the order to be set by the user instead of being defined by the number of control points. The Bezier curve is a special form of the B-Spline. More...
class	CartesianControl
class	CollisionDetection
	Collision Detection Class. More...
class	CollisionPoint
class	Cone
	A cone primitive used for modeling of objects in workcells The cone (in its local frame) will be symmetric about the y axis and its total height will be centered at y=0 with the tip of the cone at y=height/2. The cone can then be moved in its local from by specifying a local transform. More...
class	ConeData
	Reads and writes a Cone to and from an XML data file. More...
class	ConfigurationData
	Stores a named joint configuration. More...
struct	ControlParam
class	CoordinateSpace
	Specifies the properties of a coordinate space. More...
class	CoordinateVector
	Create a vector that has coordinate space information. More...
class	CriteriaProperties
class	CriteriaPropertiesRepository
	CriteriaPropertiesRepository is a repository class which holds results \ calculated by the criteria to allow data sharing. More...
class	CubicPoly
	This class allows the user to create a cubic polynomial trajectory by specifying initial and final positions and accelerations. More...
class	Cylisphere
	A cylispherical object for use in robot or as obstacle. More...
class	DeltaMC
class	DeltaWithForceMC
class	Diff
	A class for numerically computing derivatives. More...
class	DIO
	Abstract class for Digital IO. More...
class	DistanceCalculator
	Interface class for Distance Calculators. More...
class	DistanceResults
class	DistanceResultsRepository
	DistanceResultsRepository is a repository which holds DistanceResults objects, which in turn contain the witness points between manipulators and their surroundings, unit vectors pointing from the manipulator witness points, the magnitude of the distance between witness points, and the G and H functions of the witness points. More...
class	DLSEqnSolver
	This class contains methods for calculating solutions to the linear system Ax=b. More...
class	EqnSolver
	This class contains methods for calculating solutions to the linear system Ax=b. More...
class	FifthOrderPoly
	This class allows the user to create a fifth order polynomial trajectory by specifying initial and final conditions for positions,velocities and accelerations. More...
class	FixedSizeArray
	A template class that allows the creation of specific type arrays with a defined fixed size. More...
class	FixedSizeMatrix
	A template class that allows the creation of specific matrices with a defined fixed size. More...
class	FKAcceleration
class	FKJacobian
class	FKJacobianBase
class	FKJacobianMitsubishi
	This class computes a semi closed-form of the Jacobian matrix for the Mitsubishi robot. More...
class	FKJacobianPlanar3R
class	FKPosition
class	FKPositionBase
	Interface class that specifes the minimum interface a derived class should have that implements a forward position solution. Derived classes can implement this interface and also inherit from Kinematics to implement additional functionality. More...
class	FKPositionMitsubishi
	This class contains the ForwardKinematics interface for a Mitsubishi manipulator. More...
class	FKPositionPuma
	This class contains the ForwardKinematics interface for a Puma manipulator. More...
class	FKPositionSpatial3R
	This class contains the ForwardKinematics interface for a Spatial 3R manipulator. More...
class	FKVelocity
class	GeneralKinematicsHandler
class	HandPose
	Represents a 6 element vector whose 1st 3 elements hold the X,Y,Z positions and the last three hold the orientation. More...
class	HandPoseMotion
	This class is designed specifically for developing Cartesian space End-Effector motion using HandPoses. More...
class	HandPoseRepository
	HandPoseRepository is a repository class which holds HandPose data calculated by the criteria to allow data sharing. More...
class	IKCCD
class	IKDirectSearch
	This class contains methods for calculating inverse position and velocity solutions for serial manipulators using the Resolved Rate technique. More...
class	IKJacobian
	This class contains methods for calculating inverse position and velocity solutions for serial manipulators using the Resolved Rate technique. More...
class	IKJAvoidLimits
	This class is used to calculate the inverse position solution using a weighting matrix based on the joint limits. More...
class	IKJDLS
	IKJacobian with Damped Least Square (DLS) technique. More...
class	IKJGenerateOptions
	Generates a set of inverse kinematics solutions for redundant serial manipulators. More...
class	IKJReconfig
	Used to calculate the inverse position solution using the active/inactive functionality. More...
class	IKJTranspose
	This class contains methods for calculating inverse position solutions for serial manipulators (especially low DOF manipulators) using the Jacobian Transpose technique. More...
class	IKMitsubishi
	IKMitsubishi Implements a closed form solution for a standard Mitsubishi Robot. More...
class	IKPosition
	IKPosition acts as the base class for inverse position functionality. More...
class	IKPuma
	IKPuma Implements a closed form solution for a standard Puma Robot. More...
class	IKVelocity
	IKVelocity acts as the base class for inverse velocity functionality. More...
class	JointVector
	Used to pass joint position values. More...
class	KeyboardMC
class	Kinematics
class	KinematicsHandler
	KinematicsHandler describes an abstract class for computing the forward and inverse kinematics of serial robot arms. This class also checks for position limits. User should derive a specific class from this or use the GeneralKinematicsHandler class that is derived from KinematicsHandler. This class and dervied classes implement functionality that computes the forward and inverse position solution. It also checks joint travel limits and singularities. Objects of this class will always maintain a valid joint state and the corresponding cartesian state. Inputs that violate position limits or lead to singularities will not lead to an erroneous state of the system. More...
class	KraftMC
class	MagellanMC
class	Configuration
class	Control
class	ControlInformation
class	Controller
class	CTPDJointControl
class	CylisphereData
	Reads and writes a Cylisphere to and from an XML data file. More...
class	Device
class	DHData
	Reads DH parameters from a data file or programmatically create them. More...
class	Drill
	Drill provides a C++ interface to the custom drill tool for the Robotics Research Arm. This class uses DIO abstract class for IO with the drill. The tool frame for the drill is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The base plate of the drill is defined in the XY plane, with the Z axis from the drill base plate to the center contact point of the drill. More...
class	DynamicScaling
	This class allows the user to scale joint trajectories to meet velocity, acceleration or torque limits. Time is scaled. More...
class	EEPerturbation
	This class creates a series of options in a sphere around the end-effector. More...
class	ForwardDynamics
	A class to calculate forward dynamics dynamic simulation purposes. More...
class	GeneralKeyboard
class	IDLagrange
	Inverse dynamics using Lagrange. More...
class	IDNewtonEuler
	Inverse dynamics using Newton-Euler. More...
class	IDSANewtonEuler
	Standalone inverse dynamics using Newton-Euler. More...
class	IDStandAlone
	An abstract class for stand-alone inverse dynamics. More...
class	ImpedanceControl
class	ImpedanceFilter
class	Integrator
	Integrator class is used to solve an ODE problem, i.e. More...
class	InverseDynamics
	An abstract class for calculating inverse dynamics. All the calculated torque values are the "required" actuator torques (not the torques acting on the actuators). More...
class	JointControl
class	KB2017Interface
class	Limit
class	Limits
	A Limits object is used to store binary limits data for robot joints. These include min and max. These limits are generally used for Position, Velocity, Current, Acceleration and Torque. In additon to limits, the Limits object can also contain the excess error associated with a joint. These excess errors can be specified for all different limits type. Generally, they are specified for position and current. More...
class	LimitsData
	Reads Limits data from a data file or programmatically create them. LimitsType template argument should either be "Position", "Velocity", "Acceleration", "Current", or "Torque". More...
class	LimitStatusArray
class	MachineInterface
class	ManipulatorData
	Reads a manipulator model from a data file or programmatically create them. More...
class	ManualController
class	Matrix
	This class is a 2D array of doubles that contains the appropriate functionality for managing robotics data. More...
class	MatrixCol
	This class creates a pointer to a column in a Matrix. More...
class	MatrixData
	Reads data from a file that is represented in matrix format. More...
class	MatrixRepository
	MatrixRepository is a repository class which holds vector data calculated by the criteria to allow data sharing. More...
class	MatrixRow
	This class creates a pointer to a row in a Matrix. More...
class	MCDIO
	Class for digital IO using Measurement Computing DAQ boards. More...
class	ModelingObject
	Abstract base class for Primitives and Nodes.
class	ModelingObjectMap
	Contains an STL map which indexes the name of ModelingObjects (Nodes and Primitives) with their address. Useful for finding the address of a modeling Node or Primitive just by knowing its name. The key to the STL map is an OSCAR::String, the data type being stored is ModelingObject*. More...
class	MotionParameters
	This class is used to store the parameters used for generating trajectories. These parameters include: total time for trajectory, sampling time, a vector of start positions, a vector of stop positions, and a filename/matrix of motion constraints. This class is passed to the OfflineMotionPlanner before calculating a trajectory. More...
class	MotionPlanner
class	NiDaqIO
	This class is used to interface with NI DAQ IO boards. More...
class	NIDIO
	Class for digital IO using National Instruments DAQ boards. More...
class	Node
	A Node a tree modeling structure containing instances of the primitives and child nodes, as well as methods to update the locations of the Node and the modeling objects contained within this Node and its children. Basically, a Node has a list of Node's inside it. This list of nodes constitutes its children. A Node also has a list of Primitive's in it. This list of Primitives constitutes the obstacles associated with just itself. More...
class	NodeObstacleData
	Reads a node's obstacle model. A node can have primitive shapes in it and also children nodes. More...
class	ObAvData
	Contains the functionality to read/write data from/to a file for obstacle avoidance. More...
class	ObAvInfo
	Holds results of manipulator-obstacle distance calculations. More...
class	ObAvInfoRepository
	ObAvInfoRepository is a repository which holds ObAvInfo objects, which in turn contain the witness points between manipulators and their surroundings, unit vectors pointing from the manipulator witness points, the magnitude of the distance between witness points, and the G and H functions of the witness points. More...
class	OfflineMotionPlanner
	This class is used for generating and storing trajectories off-line (not in real-time). More...
class	OnlineMotionPlanner
class	Orientation
	Represents a 3 long vector whose elements hold the spatial orientation. More...
class	OSCARError
	Defines an error object that contains an integer value and an error description. More...
class	OSCARXMLErrorReporter
class	ParabolicBlend
	This class can be used to develop a parabolic blend through a set of control points. This creates a smooth 3rd degree curve that passes through each of the control points with C1 continuity. More...
class	PathBlend
	This class implements the constant velocity path blending technique developed R. H. Taylor in "Planning and Execution of Straight-Line Manipulator Trajectories." This class will develop a trajectory that smoothly interpolates straight line motions through a set of via points. More...
class	PCAccelerationLimitsAvoidance
	PCAccelerationLimitsAvoidance is a class for criteria which avoids the acceleration limits for the joints on a manipulator. PCAccelerationLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from acceleration limits. More...
class	PCADistToEEWrench
	PCADistToEEWrench is derived from PCADistToTorque and PCJacobianPseudoInverse. More...
class	PCADistToEEWrenchD1
	PCADistToEEWrenchD1 is derived from PCADistToTorque and PCJacobianPseudoInverse. This class is not currently functional and can not be instantiated. More...
class	PCADistToForce
	PCADistToForce computes the joint Forces/forces based on distances to surrounding obstacles. More...
class	PCADistToForceD1
	PCADistToForceD1 is derived from PCADistToForce. More...
class	PCADistToTorque
	PCADistToTorque computes the joint torques/forces based on distances to surrounding obstacles. More...
class	PCADistToTorqueD1
	Computes the first derivative of the torques due to artificial forces. This class is not currently functional. More...
class	PCAverageDistReciprocal
	PCAverageDistReciprocal calculates the average of the reciprocal of the minimum distance from the robot arm to obstacles. More...
class	PCAWorkCell
	PCAWorkCell uses a WorkCell to compute and store the obstacle avoidance information (see DistanceResults). More...
class	PCCompliance
	PCCompliance is an abstract class for criteria which are based on the compliance matrix. PCCompliance is derived from PCJacobian. It is an intermediate abstract class that contains the functionality to compute the compliance matrix necessary for certain criteria. More...
class	PCComplianceEigenVectors
	PCComplianceEigenVectors is an abstract class for criteria which are based on the eigenvalues or eigenvectors of the compliance matrix. PCComplianceEigenVectors is derived from PCCompliance. It is an intermediate abstract class that contains the functionality to compute the eigenvalues and eigenvectors for compliance certain criteria. This class is only available if you are using the Matrix class that uses Matlab libraries. More...
class	PCDexterity
	PCDexterity is a criteria which is based on the condition number of the Jacobian, minimum and maximum eigenvalues. The condition number specifies the Jacobian's sensitivity to error, therefore well-conditioned Jacobians are less likely to produce significant error for any specified motion. Dexterity minimizes any error at the EEF due to errors in the actuators. Another definition is the EEF's ability to react to any commanded position equally well. Since it is based on Jacobian eigenvalues, it also indicates proximity to a singulatity. PCDexterity is derived from PCJacobianEigenValues. More...
class	PCDirectionalEEFStiffness
	PCDirectionalEEFStiffness is a criteria that evaluates stiffness in a given direction. Knowing the direction of force will allow the manipulator to reorient itself in a stiffer orientation. PCDirectionalEEFStiffness is derived from PCComplianceEigenVectors. More...
class	PCEEFInertia
	PCEEFInertia is an intermediate class for criteria which are based on the Transferred EEF Inertia matrix. PCEEFInertia is derived from RRCInertia. It is an intermediate abstract class that contains the functionality to compute the transfer the Inertia matrix to the EEF necessary for certain criteria. More...
class	PCEEFKineticEnergy
	PCEEFKineticEnergy is a criteria which is based on the transferred inertia matrix and the velocity of the end-effector. This criteria attempts to minimize the kinetic energy in the direction of motion ofthe EEF. PCEEFKineticEnergy is derived from PCEEFInertia. More...
class	PCEEWrench
	PCEEWrench is derived from PCADistToEEWrench. More...
class	PCEEWrenchD1
	PCEEWrenchD1 is derived from PCAWorkCell. More...
class	PCFilter
	PCFilter should be used to filter using multiple criteria. It can be used to choose the first solution which passes all critical limits or it can be placed in a fusion scheme to filter solutions before another PC or Fusion object chooses the optimal solution. It is derived from PerformanceCriteria so the same methods are available. By deriving from PerformanceCriteria it allows multiple PCFilters to be further fused to allow more complicated combinational RRTs. More...
class	PCForceTransmissibility
	PCForceTransmissibility is a criteria which is based on the jacobian and force direction of the end-effector. This criteria attempts to maximize the ease with which joint torques are transmitted to the EEF force. PCForceTransmissibility is derived from PCJacobian. More...
class	PCFusion
	PCFusion should be used to fuse multiple criteria into a single metric to allow optimal solution selection. PCFusion is setup to be as general as possible to allow many different redundancy resolution techniques. It is derived from PerformanceCriteria so the same methods are available. By deriving from PerformanceCriteria it allows multiple PCFusion or PCFilter objects to be further fused to allow more complicated combinational RRTs. More...
class	PCGeneralizedDynamicEfficiency
	PCGeneralizedDynamicEfficiency is a criteria based upon the ratio of the largest inertial eigenvalue and the largest jacobian eigenvalue. The purpose of this criterion is to minimize joint torques in terms of inertial loading. PCGeneralizedDynamicEfficiency is derived from PCInertiaEigenValues and PCJacobianEigenValues. More...
class	PCGeneralizedInertialEfficiency
	PCGeneralizedInertialEfficiency is a criteria based upon the largest inertial eigenvalue. PCGeneralizedInertialEfficiency is derived from PCInertiaEigenValues. More...
class	PCGeneralizedStiffness
	PCGeneralizedStiffness is a criteria that evaluates the overall stiffness of a give manipulator configuration. It is done by taking the frobenius norm of the stiffness matrix. PCGeneralizedStiffness is derived from PCCompliance. More...
class	PCGeneralizedTorqueMinimization
	PCGeneralizedTorqueMinimization is a criteria based upon the Inertia and JacobianPseudoInverse matrices. The infinity norms of the Inertia and JacobianPseudoInverse matrices are multiplied together to get an estimate on the necessary torque to move the manipulator from one configuration to another. PCGeneralizedTorqueMinimization is derived from PCInertia and PCJacobianPseudoInverse. More...
class	PCGeneralizedVelocityMinimization
	PCGeneralizedVelocityMinimization is a criteria based upon the JacobianPseudoInverse, that aims to reduce joint velocities. It only takes the largest row sum of the pseudoinverse which is the largest transformation of a joint velocity. This criteria does not actually calculate velocities so there is no check to make sure operation velocity limits are not violated. PCGeneralizedVelocityMinimization is derived from PCJacobianPseudoInverse. More...
class	PCInertia
	PCInertia is an abstract class for criteria which are based on the inertia matrix. PCInertia is derived from PerformanceCriteria. It is an intermediate abstract class that contains the functionality to compute the inertia matrix necessary for certain criteria. More...
class	PCInertiaEigenValues
	PCInertiaEigenValues is an abstract class for criteria which are based on the inertia eigenvalues. PCInertia is derived from PCInertia. It is an intermediate abstract class that contains the functionality to compute the inertia eigenvalues necessary for certain criteria. More...
class	PCInertialFrobeniusNorm
	PCInertialFrobeniusNorm takes the frobenius norm of the iStar inertia matrix. Minimizing the effective inertia matrix leads to a decrease in the kinetic energy of the system. PCGeneralizedTorqueMinimization is derived from PCInertia. More...
class	PCInverseMeasureOfTransmissibility
	PCInverseMeasureOfTransmissibility is a criteria which is based on determinant of the jacobian. This criteria attempts to maximize the ease with which joint velocities are transmitted to the EEF velocities. This criteria is computationally fast and can have multiple physical meanings. Because of the dual nature of the Jacobian, transmission transmissibility or velocity transmissibility could be optimized. The determinant is also an indicator of proximity to a singularity. PCInverseMeasureOfTransmissibility is derived from PCJacobian. More...
class	PCJacobian
	PCJacobian is an abstract class for criteria which are based on the jacobian. PCJacobian is derived from PerformanceCriteria. It is an intermediate abstract class that contains the functionality to compute jacobians. Derived classes update the necessary repositories by calling the protected method update(). More...
class	PCJacobianEigenValues
	PCJacobianEigenValues is an intermediate abstract class which adds the functionality to calculate jacobian eigenvalues. PCJacobianEigenValues is derived from PCJacobian. More...
class	PCJacobianFrobeniusNorm
	PCJacobianFrobeniusNorm is a criteria which is based on the frobenius norm of the Jacobian matrix. This criterion can be viewed as a generalized efficiency criterion for both velocity and torque transmission. Mitch Pryor suggests this is the most effective criteria in terms of avoiding singularities. PCJacobianFrobeniusNorm is derived from PCJacobian. More...
class	PCJacobianPseudoInverse
	PCPseudoInverse is an intermediate abstract class which adds the functionality to calculate jacobian pseudoinverses. PCJacobianPseudoInverse is derived from PCJacobian. More...
class	PCJointRangeAvailability
	PCJointRangeAvailability is a criteria which calculates the distance from the joint limits of a manipulator. PCJointRangeAvailability is derived from PCVectorLimits. The methods to get and set individual joint parameters are in PCVectorLimits. More...
class	PCJointTorque
	Minimizes joint torques due to artificial forces. More...
class	PCKeyboard
class	PCKeyboardMC
class	PCKineticEnergy
	PCKineticEnergy calculates the kinetic energy of the manipulator using the iStar inertia matrix and the current positions. Time is not explicitly included in the formulation, so the criteria value is not the true kinetic energy value, but allows solutions to be ranked. It could easily be modified to take into account time. PCKineticEnergy is derived from PCInertia. More...
class	PCLinkForce
	PCLinkForce minimizes the average of the artificial forces acting on the links. More...
class	PCLoadTorqueMinimization
	PCLoadTorqueMinimization is a criteria which is based on the Jacobian matrix. This criterion attempts to reduce the actuator torques due to the load at the EEF. PCLoadTorqueMinimization is derived from PCJacobian. More...
class	PCMagneticEEF
	PCMagneticEEF is a criteria which calculates the distance to a point. PCMagneticEEF works like a magnet attracting the EEF to the specified point or repelling the EEF from an obstacle. More...
class	PCMeasureOfTransmissibility
	PCMeasureOfTransmissibility is a criteria which is based on determinant of the jacobian. This criteria attempts to maximize the ease with which joint velocities are transmitted to the EEF velocities. This criteria is computationally fast and can have multiple physical meanings. Because of the dual nature of the Jacobian, transmission transmissibility or velocity transmissibility could be optimized. The determinant is also an indicator of proximity to a singularity. PCMeasureOfTransmissibility is derived from PCJacobian. More...
class	PCPotentialEnergy
	PCPotentialEnergy is a criteria that calculates the potential energy in the manipulator due to deflections. Deflections due to forces at the EEF are the only deflections considered. Minimizing this criteria should reduce deflections due to loads at the EEF. PCPotentialEnergy is derived from PCCompliance. More...
class	PCRoboworksInterface
	This class multiply inherits from RoboworksInterface and PowerCubeBase classes. This is an interface for PowerCube simulation (when simulation is done in Roboworks.). It has following functionality. -Object construction and initialization -Homing -Resetting -Halting -Getting and setting positions of modules and gripper(if any) Note: for giving position commands call SetServoValue() (See RobotServoInterface.h). The implementation is in SetPosition(). More...
class	PCSHandPose
class	PCSingularityAvoidance
	PCSingularityAvoidance is a criteria which is based on the minimum eigenvalue of the Jacobian. Exclusively tracking the minimum singular value may exhibit a better indication of a manipulator's nearness to a mathematical singularity. Transmissibilty can be improved by maximizing the distance from singularities, therefore minimizing the joint torques required to maintain a desired EEF force. PCSingularityAvoidance is derived from PCJacobianEigenValues. More...
class	PCSmallestMinDist
	PCSmallestMinDist calculates the minimum distance from the robot arm to any obstacle in the environment. More...
class	PCTorqueLimitsAvoidance
	PCTorqueLimitsAvoidance is a class for criteria which avoids the torque limits for the joints on a manipulator. PCTorqueLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from torque limits. More...
class	PCVectorLimits
	PCVectorLimits is an abstract class for criteria which avoids the limits of a vector. More...
class	PCVelocityLimitsAvoidance
	PCVelocityLimitsAvoidance is a class for criteria which avoids the velocity limits for the joints on a manipulator. PCVelocityLimitsAvoidance is derived from PCVectorLimits. It is a class that computes the manipulator's distance from velocity limits. More...
class	PCVelocityTransmissibility
	PCVelocityTransmissibility is a criteria which is based on the jacobian pseudo-inverse and the velocity of the end-effector. This criteria attempts to maximize the efficiency with which joint velocities are transmitted to the EEF velocity. PCVelocityTransmissibility is derived from PCJacobian. More...
class	PerformanceCriteria
	PerformanceCriteria should be used to select a solution from a set of options for a manipulator. More...
class	Perturbation
	Perturbation can be called to generate patterned perturbations for Vector and RRJointVector. More...
class	Plane
	Define a planar primitive for use in robot obstacle avoidance. More...
class	PlaneData
	Reads and writes a Plane to and from an XML data file. More...
class	Polytope
	Class for STL based polytope obstacle models Currently an empty class which can be instantiated but can not be used for anything useful. More...
class	PolytopeData
	Reads and writes a Polytope to and from an XML data file. More...
class	PowerCubeBase
	This is an abstract class for Amtec's PowerCube Interface (both hardware and simulation modules inherit from this class.) having following functionality -Initialization -Homing -Resetting -functionality related to gripper -retrieving and setting different attributes (like current limits). More...
class	PowerCubeInterface
	This class, derived from PowerCubeBase class, implements the software interface to control mechanism/robot hardware assembled from PowerCube modules manufactured by Amtec Robotics (http://www.amtec-robotics.com/index.html) that is part of the Schunk group(http://www.schunk.com/). More...
class	Primitive
	Base for geometric primitives.
class	Quaternion
	Used to reperesent a quaternion rotation. More...
class	RedundantKinematicsHandler
class	Relay
class	Repository
	Repository is a base repository class from which all repository types will derive. These repositories store data computed by the criteria in order to prevent repeat calculations. All computational ability is in the performance criteria - repositories store data only. Repository contains the functionality to keep track of whether the repository has been updated. The methods to get and set the data members inside the repository were placed in the derived template class TypeRepository so the same methods could be used for several repository types. The reason this base class is necessary is because RepositoryList cannot point to a template class. More...
class	RepositoryList
	RepositoryList is a list which holds Repository objects. This list will be passed to criteria to give them a place to read and write data for criteria computations. More...
class	RK4
	fixed step size Runge Kutta Integrator Used to integrate ODEs in a manner similar to ode45 in matlab More...
class	RobixInterface
class	RobotData
	Acts as the base class for all classes that are used to read and parse data files. More...
class	RobotServoInterface
class	RoboworksInterface
class	Rot3by3
	This class is used to represent a 3x3 rotation matrix. More...
class	RRMotionPlan
	This class is the base class for the Motion Planning library. It contains the functionality for setting the motion parameters and performs some of the low level calculations. More...
class	RROnlineMotionPlanner
	This class defines the base interface for performing online motion planning. This class is not currently implemented. More...
class	RRStatics
	An abstract class for calculating static forces. More...
class	RSIMC
class	RungeKutta
class	Saw
	Saw provides a C++ interface to the custom saw tool for the Robotics Research Arm. This class uses Digital IO hardware for IO with the saw. The tool frame for the saw is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The tool point for the saw is defined as point on the leading edge of the skid plate of the saw which is colinear with the saw blade. More...
class	ScalarRepository
	ScalarRepository is a repository class which holds scalar data calculated by the criteria to allow data sharing. More...
class	ScaleInverseF
	\ ScaleInverseF One type of APF where Scalar function goes as the inverse of the argument The function is F(x) = k*[(mx-mn)/(x-mn)]^z + thresh, so that as (x->inf), (F(x)->thresh), (x=mx), (F(x) = k + thresh), and as (x->mn), (F(x)->inf). Note: this function object does not check for x < mn. A special case is when k=1, z=1, mx=1, mn=0, and thresh=0, then F(x) = 1/x.
class	ScaleInverseVanishF
	\ ScaleInverseVanishF One type of APF where Scalar function starts from infinity at a certain value and decreases as the argument grows until vanishing completely at a certain value. The function is F(x) = k*[(mx-x)/(x-mn)]^z + thresh, so that if (x>=mx), (F(x) = thresh), and as (x->mn), (F(x)->inf). If thres = 0, then it means that APF will have no effect when x >= mx. Note: this function object does not check for x < mn.
class	Sensor
	Base class for all Sensors. Each Sensor should be derived from this class and should support all the methods. More...
class	ServoInterface
class	Shared
class	SimpleObAv
class	Simulator
class	SkeletalPrimitive
	Base for skeletal geometric primitives. More...
class	SpaceballMC
class	SpatialXform
	This class represents a 6 by 6 spatial transformation matrix. More...
class	SpecificationsData
	Reads specifications for a particular system (robot, tool, etc.) from a data file or programmatically create them. More...
class	Sphere
	Define a spherical primitive for use in robot obstacle avoidance. More...
class	SphereData
	Reads and writes a Sphere to and from an XML data file. More...
class	Spline
	An abstract class defining the base-level interface for spline curve generation. This includes the ability to set, insert, and delete the control points. More...
class	SprayGun
	SprayGun provides a C++ interface to the custom spray gun tool for the Robotics Research Arm. This class uses digitial IO data-acquisition hardware for IO with the spray gun. The tool frame for the spray gun is also set during the construction of this object. A call to GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The tool point for the spray gun is defined at the output nozzle of the spray gun. More...
class	TCP
	This class contains base interface for TCP/IP communication. More...
class	TCPClient
	This class contains functionality for setting up a TCP client. More...
class	TCPServer
	This class contains functionality for setting up a TCP server. More...
class	Tensor
	Represents a tensor (basically an array of matrices). More...
class	TensorData
	Reads data from a file that is represented in tensor format (array of matrices). More...
class	TensorRepository
	TensorRepository is a repository class which holds tensor data calculated by the criteria to allow data sharing. More...
class	ThreeStateTool
	Base class for all tools that support Forward, Reverse, and Off functionality. More...
class	Timer
	Measures code execution time. More...
class	Tool
	Base class for all end effector tools. Each tool should be derived from this class and should support all the methods. More...
class	ToolChanger
	ToolChanger provides a C++ interface to the tool changers mounted on the Robotics Research Arm. This class uses ditial IO data-acquisition drivers for IO with the tool changers. The tool frame for the ToolChangers is also set during the construction of this object. A call to #GetToolFrame will return the tool frame. The units in which the tool frame is returned are inches. The base plate of the tool changer is defined in the XY plane, with the Z axis from the tool changer base plate towards the tool attachment plate. More...
class	ToolData
	Reads a tool model from a data file or programmatically create them. More...
class	TOSMC
class	TwoStateSwitch
	Base class for all switches that support On and Off functionality. More...
class	TwoStateTool
	Base class for all tools that support Forward (On) and Off functionality. More...
class	TypeRepository
	TypeRepository is a repository template class which holds the functionality for retrieving and setting data in the repositories. Derived classes will set the template type and allocate the type size depending on needs. The type has to be a pointer so get and set methods will be taking or returning pointers. More...
class	Vector3
	Represents a spatial position vector. More...
class	VectorArray
	Stores arrays of vectors. More...
class	VectorNumeric
	Represents a vector. More...
class	VectorRepository
	VectorRepository is a repository class which holds vector data \ calculated by the criteria to allow data sharing. More...
class	WorkCell
	Contains a geometric description of the work cell (from an ObAvData object) and computes witness points (minimum distances between robots and other models) and derivatives of witness points (stored in an ObAvInfo object). More...
class	WorkcellData
	Reads a Workcell model from a data file or programmatically create them. More...
class	Xform
	Defines a 4 by 4 homogeneous transformation matrix. More...
class	XMLData
	Reads OSCAR specific data specifiedf in XML This is the base class for all data to be loaded in XML format. This class sets up the XML parser (Xerces), sets its properties (validation, schema, etc.) sets namespace, etc. Dervied classes have to define the parseParameters method for the specific data they are loading. More...
class	XMLDHData
	Reads DH parameters from a data file or programmatically create them. More...
Typedefs
typedef std::string	String
typedef Array< Vector7 >	Vector7Array
typedef Array< int >	ArrayI
typedef Tensor *	TensorP
typedef unsigned long	ADDR
typedef char	Control8Bit
typedef short	Control16Bit
typedef float	Control32Bit
typedef VectorNumeric< Control8Bit >	Control8BitArray
typedef VectorNumeric< Control16Bit >	Control16BitArray
typedef VectorNumeric< Control32Bit >	Control32BitArray
typedef Array< enum CoordinateStatus >	CoordinateStatusArray
typedef double *	DoubleP
typedef Matrix *	Matrixp
typedef Array< bool >	BoolArray
typedef Array< char >	CharArray
typedef VectorNumeric< unsigned int >	VectorUINT
typedef VectorNumeric< int >	VectorI
typedef VectorNumeric< float >	VectorF
typedef VectorNumeric< double >	VectorD
typedef VectorNumeric< double >	Vector
typedef Vector3	Vector3D
typedef FixedSizeArray< Vector, 7 >	Vector7
typedef Vector *	VectorP
typedef std::vector< Vector3 >	Vector3vec
typedef std::list< Node * >	NodeList
typedef std::list< Primitive * >	PrimitiveList
typedef FixedSizeArray< Vector, 6 >	EEFVelocity
typedef FixedSizeArray< Vector, 6 >	ForceDirection
typedef std::map< String, Repository * >	RepositoryMap
Enumerations
enum	LimitStatus { MinLimitViolation = -1, NoLimitViolation = 0, MaxLimitViolation = 1 }
enum	CartesianCoordinateMode { World, Tool, Part }
enum	CoordinateStatus { Active = true, Inactive = false }
enum	AngleUnits { Radians = 1, Degrees = 2 }
enum	HandPoseInterp { NormalInterp, QuaternionLERP, QuaternionSLERP }
enum	fileEnums {   ROBOT, BRANCH, OBSTACLE, SPHERE,   CYLISPHERE, PLANE, BOX, RADIUS,   FRAME, OBSTPOINT, INVALID }
enum	MinOrMax { Minimize, Maximize }
Functions
template<class err_t> err_t &	DUMMY_ERROR (const err_t &theError)
void	DisplayError (const String &eString)
void	DisplayDebug (const String &debugString)
void	DisplayTrace (const String &traceString)
void	DisplayError (const OSCARError &err)
void	Display (const String &dispString)
template<class T> void	Input (T &t)
std::ostream &	operator<< (std::ostream &strm, const OSCARError &err)
OSCARError	operator+ (const OSCARError &e1, const OSCARError &e2)
template<class T> String	ToString (const T &t)
int	ByteSwap (int in)
float	ByteSwap (float in)
double	ByteSwap (double in)
void	ByteSwap (Vector &v)
void	ByteSwap (VectorF &v)
void	ByteSwap (VectorI &v)
std::ostream &	operator<< (std::ostream &out, const DHData &D)
std::ostream &	operator<< (std::ostream &out, const MatrixData &M)
OSCARError	fromException (const DOMException &toCatch)
OSCARError	fromException (const XMLException &toCatch)
OSCARError	fromException (const SAXParseException &toCatch)
std::ostream &	operator<< (std::ostream &out, const TensorData &T)
template<class Type> std::ostream &	operator<< (std::ostream &os, const Array< Type > &a)
template<class Type> std::istream &	operator>> (std::istream &is, Array< Type > &a)
std::istream &	operator>> (std::istream &is, bool &b)
Vector	GetRow (unsigned int row, const Matrix &m)
Vector	GetCol (unsigned int col, const Matrix &m)
void	GetRow (Vector &result, unsigned int row, const Matrix &m)
void	GetCol (Vector &result, unsigned int col, const Matrix &m)
Vector3	Cross3 (const Vector3 &v1, const Vector3 &v2)
Vector3	Cross3Unit (const Vector3 &v1, const Vector3 &v2)
Matrix	operator * (double a, const Matrix &m)
Vector3	operator * (const Xform &lhs, const Vector3 &rhs)
void	Multiply (const Xform &lhs, const Vector3 &rhs, Vector3 &result)
template<class Type> VectorNumeric< Type >	operator * (Type a, const VectorNumeric< Type > &v)
template<class To, class From> To	Convert (const From &f)
template<class Type> Type	Dot (const VectorNumeric< Type > &v1, const VectorNumeric< Type > &v2)
std::ostream &	operator<< (std::ostream &out, const Matrix &m)
std::ostream &	operator<< (std::ostream &out, const MatrixRow &m)
std::ostream &	operator<< (std::ostream &out, const MatrixCol &m)
std::ostream &	operator<< (std::ostream &strm, const Tensor &t)
bool	GenerateLine (const Vector &initialPosition, const Vector &finalPosition, Matrix &pathTrajectory, unsigned int steps, unsigned int degree=2, OSCARError &err=DUMMY_ERROR(noError), char *constraintsFileName=NULL)
bool	InterpolateSlerp (const Quaternion &initialQuaternion, const Quaternion &finalQuaternion, Quaternion &resultQuaternion, double t, OSCARError &err=DUMMY_ERROR(noError))
bool	GenerateHandPath (const HandPose &initialHand, const HandPose &finalHand, Matrix &handTrajectory, unsigned int steps, unsigned int degree=2, HandPoseInterp mode=NormalInterp, OSCARError &err=DUMMY_ERROR(noError))
bool	distToForce (const ArtificialPotentialF &func, const Matrix &minDist, Matrix &forces)
bool	forceToTorque (const Tensor &gDist, const Matrix &forces, Vector &torque)
bool	forceToTorque (const DistanceResults &results, std::list< Primitive * > &armPrimitives, std::list< Primitive * > &enviPrimitives, Vector &torque)
bool	torqToEEWrench (const Vector &torques, const Matrix &jacobInv, Vector &eeForce)
bool	distToForceD1 (const ArtificialPotentialF &func, const Matrix &minDist, const Matrix &forces, Matrix &forcesD1)
bool	forceToTorqueD1 (const std::vector< Tensor * > &hDist, const Tensor &gDist, const Matrix &forces, const Matrix &forcesD1, const Vector &jointVel, const Vector &torques, Vector &torquesD1)
bool	torqToEEWrenchD1 (const Tensor &eeTransHFunc, const Tensor &eeRotHFunc, const Matrix &jacobianInv, const Vector &jointVel, const Vector &torques, const Vector &torquesD1, const Vector &eeForce, Vector &eeForceD1)
const vector< string >	fileTags (stringTags,&stringTags[INVALID])
double	PointLine (const Vector3 &a, const Vector3 &b0, const Vector3 &b1, Vector3 &bWit, Vector3 &unitVec, double &t)
double	LineLine (const Vector3 &a0, const Vector3 &a1, const Vector3 &b0, const Vector3 &b1, Vector3 &aWit, Vector3 &bWit, Vector3 &unitVec, double &t0, double &t1)
double	testEndPoints (const Vector3 &a0, const Vector3 &a1, const Vector3 &b0, const Vector3 &b1, Vector3 &aWit, Vector3 &bWit, Vector3 &unitVec, double &t0, double &t1)
double	LineFacet (const Vector3 &a0, const Vector3 &a1, const std::vector< Vector3 > &facetPoints, Vector3 &unitVec, double &t1, double &t2)
double	LineFacet (const Vector3 &a0, const Vector3 &a1, const std::vector< Vector3 > &facetPoints, const Vector3 &facetNormal, Vector3 &unitVec, double &t1, double &t2)
void	calcJointTorques (const Xform *globalXforms, const Vector3 &forceLocation, const Vector3 &force, unsigned int linkIndex, Vector &torques)
void	calcJointTorquesToBase (const Xform *globalXforms, const Vector3 &forceLocation, const Vector3 &force, unsigned int linkIndex, Vector &torques)
void	calcJointTorquesToEE (const Xform *globalXforms, const Vector3 &forceLocation, const Vector3 &force, unsigned int linkIndex, Vector &torques)
bool	CalcJointTorques (FKPosition &fk, const Vector &jointPositions, Vector &torques, const Vector3 &forceLocation, const Vector3 &force, unsigned int linkIndex)
bool	CalcJointTorques (const FKPosition &fk, Vector &torques, const Vector3 &forceLocation, const Vector3 &force, unsigned int linkIndex)
void	calculateSupportReactionForces (const Vector3 &base0, const Vector3 &base1, const Vector3 &forceLocation, const Vector3 &force, Vector3 &base0FRX, Vector3 &base1FRX)
void	calculateSupportReactions (const Vector3 &base0, const Vector3 &base1, const Vector3 &forceLocation, const Vector3 &force, Vector3 &base0FRX, Vector3 &base0TRX, Vector3 &base1FRX, Vector3 &base1TRX)
template<class T> VectorNumeric< T > &	RowToVector (const Matrix &matx, unsigned int row, VectorNumeric< T > &copy)
template<class T> VectorNumeric< T > &	ColToVector (const Matrix &matx, unsigned int col, VectorNumeric< T > &copy)
std::ostream &	operator<< (std::ostream &out, const ObAvData &arg)
Variables
const OSCARError	noError
const OSCARError	notSupported
const OSCARError	notInitialized
const OSCARError	HardwareErrors
const OSCARError	powerFailure
const OSCARError	connectionFailure
const OSCARError	deviceNotReady
const OSCARError	initializeFailure
const OSCARError	registerReadFailure
const OSCARError	registerWriteFailure
const OSCARError	portOpenFailure
const OSCARError	portReadFailure
const OSCARError	portWriteFailure
const OSCARError	notClosed
const OSCARError	parameterNotMatch
const OSCARError	valueNotSet
const OSCARError	parameterNotValid
const OSCARError	positionExcessError
const OSCARError	velocityExcessError
const OSCARError	torqueExcessError
const OSCARError	currentExcessError
const OSCARError	armPowerOffError
const OSCARError	illegalRoboWorksTagNameError
const OSCARError	robixDLLError
const OSCARError	robixEIError
const OSCARError	robixRobotError
const OSCARError	robixServoError
const OSCARError	nidaqError
const OSCARError	measurementComputingError
const OSCARError	powerCubeDLLError
const OSCARError	powerCubeCommError
const OSCARError	powerCubeLimitError
const OSCARError	powerCubePowerError
const OSCARError	powerCubeGeneralError
const OSCARError	kb2017GeneralError
const OSCARError	kb2017HomeError
const OSCARError	kb2017CommError
const OSCARError	illegalMotionTime
const OSCARError	roboTalkError
const OSCARError	atisensorSaturationError
const OSCARError	atisensorTransducerError
const OSCARError	atisensorMultipleError
const ADDR CONTROL	BYTE = 0x170
const ADDR RES NULL	STATUS = 0x002
const ADDR JOINT	OFFSET = 0x0a8
const ADDR POS LOOP	GAIN = 0x0d0
const ADDR EXCESS	ERROR = 0x120
const ADDR JOINT COM	MODE = 0x176
const ADDR COM DIV	NUMBER = 0x006
const ADDR POS	COMMAND = 0x008
const ADDR COMMAND	FLAG = 0x216
const ADDR	JOINTPOSITION = 0x218
const ADDR	JOINTVELOCITY = 0x268
const ADDR	JOINTTORQUE = 0x290
const ADDR DATA	LOCK = 0x2c6
const ADDR INTERRUPT	MASK = 0x2be
const ADDR MACHINE	START = 0x2ba
const ADDR MACHINE	TYPE = 0x2c0
const Control8Bit	J1CK = 0x01
const Control8Bit	J1CCK = 0x02
const Control8Bit	J2CK = 0x03
const Control8Bit	J2CCK = 0x04
const Control8Bit	J3CK = 0x05
const Control8Bit	J3CCK = 0x06
const Control8Bit	J4CK = 0x07
const Control8Bit	J4CCK = 0x08
const Control8Bit	J5CK = 0x09
const Control8Bit	J5CCK = 0x0a
const Control8Bit	J6CK = 0x0b
const Control8Bit	J6CCK = 0x0c
const Control8Bit	J7CK = 0x0d
const Control8Bit	J7CCK = 0x0e
const Control8Bit	J8CK = 0x0f
const Control8Bit	J8CCK = 0x10
const Control8Bit	J9CK = 0x11
const Control8Bit	J9CCK = 0x12
const Control8Bit	J10CK = 0x13
const Control8Bit	J10CCK = 0x14
const Control8Bit	J11CK = 0x15
const Control8Bit	J11CCK = 0x16
const Control8Bit	J12CK = 0x17
const Control8Bit	J12CCK = 0x18
const Control8Bit	J13CK = 0x19
const Control8Bit	J13CCK = 0x1a
const Control8Bit	J14CK = 0x1b
const Control8Bit	J14CCK = 0x1c
const Control8Bit	J15CK = 0x1d
const Control8Bit	J15CCK = 0x1e
const Control8Bit	J16CK = 0x1f
const Control8Bit	J16CCK = 0x20
const Control8Bit	J17CK = 0x21
const Control8Bit	J17CCK = 0x22
const Control8Bit	NullRobot = 0x30
const Control8Bit	AutoHome = 0x50
const unsigned int	KB2017DOF = 17
const float	defaultExcessError = 10.0F * (float)DegToRad
const float	defaultPositionLoopGains = 0.67F
const float	countsPerRadian [KB2017DOF]
const float	FBcountsPerFtlb [KB2017DOF]
const float	CmdFtlbPerCount [KB2017DOF]
const float	FBCntPerDegPerSec [KB2017DOF]
const float	CmdDegPerSecPerCnt [KB2017DOF]
float	MinJointLimit [KB2017DOF]
float	MaxJointLimit [KB2017DOF]
Control16Bit	offset [KB2017DOF] = {0x0024,0xff24,0x5fbb,0x746f,0x37ed,0xdf77,0x4b9d,0xef72,0x430e,0x835c,0x1d1d,0x54be,0x30ad,0xafda,0xe1a2,0xb9aa,0x0097}
const unsigned int	LimitMatrixCol = 2
const OSCARError	DynamicsErrors
const OSCARError	dofAndMassDataMismatch
const OSCARError	dofAndInertiaDataMismatch
const OSCARError	undefinedJacobianTranspose
const OSCARError	undefinedTransformations
const OSCARError	undefinedGHFunctions
const OSCARError	FileIOErrors
const OSCARError	fileOpenError
const OSCARError	badFileData
const OSCARError	dataSizeNotMatch
const OSCARError	dhParamsIllFormed
const OSCARError	xmlError
const OSCARError	jointLimitsNotDefined
const OSCARError	jointOffsetsNotDefined
const OSCARError	dhParametersNotDefined
const OSCARError	dhFrameNamesNotDefined
const OSCARError	FKErrors
const OSCARError	fkDefinitionError
const OSCARError	outputCoordSizeMismatch
const OSCARError	jointDoesNotExist
const OSCARError	noLockedJntsOutOfRange
const OSCARError	argumentSizeMismatch
const OSCARError	argumentSizeIncorrect
const OSCARError	jointLockedTwice
const OSCARError	invalidOutputSpace
const OSCARError	invalidInputSpace
const OSCARError	noPartialJacobianExists
const OSCAR::OSCARError	jointLimitViolation
const OSCARError	IKErrors
const OSCARError	ikDefinitionError
const OSCARError	badLimitsData
const OSCARError	minMOTReached
const OSCARError	maxIterationCountReached
const OSCARError	singularity
const OSCARError	illegalNullSpaceSize
const OSCARError	outOfReach
const unsigned int	SizeControl8Bit = 1
const unsigned int	SizeControl16Bit = 2
const unsigned int	SizeControl32Bit = 4
const double	PI = 3.14159265358979323846
const double	TWOPI = 2.*PI
const double	TwoPI = 2.*PI
const double	RadToDeg = 180./PI
const double	DegToRad = PI/180.
const double	Tiny = 1.0e-20
const double	Epsilon = 0.00001
const double	AngleTolerance = 0.00005
const OSCARError	MathErrors
const OSCARError	mathDefinitionError
const OSCARError	vectorSizeMismatch
const OSCARError	matrixSizeMismatch
const OSCARError	matrixRowSizeMismatch
const OSCARError	matrixColumnSizeMismatch
const OSCARError	matlabRelated
const OSCARError	tensorArraySizeMismatch
const OSCARError	tensorMatrixSizeMismatch
const OSCARError	arraySizeMismatch
const OSCARError	nonSquareMatrix
const OSCARError	quaternionSingularity
const OSCARError	invalidArraySize
const OSCARError	outOfRange
const OSCARError	limitsNotSet
const OSCARError	limitsViolation
const OSCARError	matrixSingularity
const OSCARError	invalidValue
const OSCARError	divideByZero
const OSCARError	invalidRotationMatrix
const OSCARError	MotionPlanErrors
const OSCARError	generationError
const OSCARError	constraintsError
const OSCARError	constraintsExceeded
const OSCARError	parameterError
const OSCARError	slerpFailure
const string	stringTags [] = {"ROBOT","BRANCH","OBSTACLE","SPHERE","CYLISPHERE","PLANE","BOX","RADIUS","FRAME","POINT","INVALID"}
const OSCARError	ObstacleAvoidanceError
const OSCARError	CollisionDetectionError
const OSCARError	sampleError
const OSCARError	PCErrors
const OSCARError	repositoryAlreadyExists
const OSCARError	noValidSolution
const OSCARError	normalizeSchemeMismatch
const OSCARError	directionMismatch
const OSCARError	noGradientDefined

---

Detailed Description

All rights reserved.

This software and documentation constitute an unpublished work and contain valuable trade secrets and proprietary information belonging to University. None of the foregoing material may be copied or duplicated or disclosed without the express, written permission of University. UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall University be liable for incidental, special, indirect, direct or consequential damages or loss of profits, interruption of business, or related expenses which may arise from use of software or documentation, including but not limited to those resulting from defects in software and/or documentation, or loss or inaccuracy of data of any kind.

Purpose : Declares the Kinematics class

----------------------------------------------------------------------------

$Revisions$

Log

Kinematics.h,v

Revision 1.7 2005/03/17 21:27:53 chetan Changed RRReferenceFrame to ReferenceFrame

Revision 1.6 2005/03/14 21:53:05 pmarch Added to namespace OSCAR and removed "RR" from front of class names.

Revision 1.5 2004/11/15 17:23:17 chetan Improved error handling in Kinematics. Made changes to derived classes to accomodate changed interface of Kinematics

Revision 1.4 2004/07/23 22:19:55 chetan Made changes to compile with Warning Level 4 and also under the latest C++ standard

Revision 1.3 2004/05/26 20:10:07 pmarch Added /defgroup and /ingroup tags.

Revision 1.2 2003/09/09 19:36:00 rctaylor Added RRReferenceFrame enum enumerating the global and local frame possibilities.

Revision 1.1 2003/08/18 20:32:11 pmarch Initial commit of ForwardKinematics

---

Typedef Documentation

typedef unsigned long OSCAR::ADDR

typedef Array<int> OSCAR::ArrayI

typedef Array<bool> OSCAR::BoolArray

typedef Array<char> OSCAR::CharArray

typedef short OSCAR::Control16Bit

typedef VectorNumeric<Control16Bit> OSCAR::Control16BitArray

typedef float OSCAR::Control32Bit

typedef VectorNumeric<Control32Bit> OSCAR::Control32BitArray

typedef char OSCAR::Control8Bit

typedef VectorNumeric<Control8Bit> OSCAR::Control8BitArray

typedef double* OSCAR::DoubleP

typedef FixedSizeArray< Vector, 6 > OSCAR::EEFVelocity

typedef FixedSizeArray< Vector, 6 > OSCAR::ForceDirection

typedef Matrix* OSCAR::Matrixp

typedef std::list<Node*> OSCAR::NodeList

typedef std::list<Primitive*> OSCAR::PrimitiveList

typedef std::map< String,Repository* > OSCAR::RepositoryMap

typedef std::string OSCAR::String

typedef Tensor * OSCAR::TensorP

typedef VectorNumeric<double> OSCAR::Vector

typedef Vector3 OSCAR::Vector3D

typedef std::vector<Vector3> OSCAR::Vector3vec

typedef FixedSizeArray<Vector, 7> OSCAR::Vector7

typedef Array<Vector7> OSCAR::Vector7Array

typedef VectorNumeric<double> OSCAR::VectorD

typedef VectorNumeric<float> OSCAR::VectorF

typedef VectorNumeric<int> OSCAR::VectorI

typedef Vector* OSCAR::VectorP

typedef VectorNumeric<unsigned int> OSCAR::VectorUINT

---

Enumeration Type Documentation

enum OSCAR::AngleUnits

Enumeration values: Radians  Degrees

enum OSCAR::CartesianCoordinateMode

CartesianCooordinateMode is used to specify the frame the cartesian target coordinates are expressed in. World implies that the robot cartesian position is expressed in the global coordinates. Usually, these are the base frame of the robot or any other frame in which the robot forward kinematics is computed. Tool implies the coordinate frame attached to the end-effector. This frame is normally what is computed by the forward kinematics and represents the last frame of the robot. The Tool cooridnates change as the robot moves. Tool is usually used to jog the robot along the axes of the tool. Part implies a frame attached to a workpiece in the robot workspace. If Part is selected, then the robot end-effector is commanded to move in part coordinates. A 0 cartesian command to the robot will lead to the end-effector moving to the workpiece for which the part coordinates have been defined. Enumeration values: World  Tool  Part

enum OSCAR::CoordinateStatus

Enumeration values: Active  Inactive

enum OSCAR::fileEnums

Enumeration values: ROBOT  BRANCH  OBSTACLE  SPHERE  CYLISPHERE  PLANE  BOX  RADIUS  FRAME  OBSTPOINT  INVALID

enum OSCAR::LimitStatus

Enumeration LimitStatus contains integer values for the max, min, and no limit violations. Enumeration LimitStatus contains integer values for the max, min, and no limit violations. Enumeration values: MinLimitViolation  NoLimitViolation  MaxLimitViolation

enum OSCAR::MinOrMax

Enumeration values: Minimize  Maximize

---

Function Documentation

void ByteSwap (  VectorI &    v )

void ByteSwap (  VectorF &    v )

void ByteSwap (  Vector &    v )

double ByteSwap (  double    in )  [inline]

float ByteSwap (  float    in )  [inline]

int ByteSwap (  int    in )  [inline]

bool distToForce (  const ArtificialPotentialF &    func, const Matrix &    minDist, Matrix &    forces )

Maps distances to forces. Parameters: func  ArtificialPotentialF function object which does the mapping minDist  Matrix of dimention (a x b), containing minimum distances forces  Matrix of dimention (a x b), where the computed forces will be stored Returns: true - success, false if minDist and forces are not the same dimension

bool distToForceD1 (  const ArtificialPotentialF &    func, const Matrix &    minDist, const Matrix &    forces, Matrix &    forcesD1 )

Computes derivative (wrt distance) of artificial forces from an artificial potential field. Parameters: func  ArtificialPotentialF function object which does the mapping minDist  Matrix of dimention (a x b), containing minimum distances forces  Matrix of dimention (a x b), containing forces forcesD1  Matrix of dimention (a x b) to hold first derivative of forces wrt distance Returns: true - success, false if minDist, forces & forrcesD1 are not the same dimension

template<class err_t> err_t& DUMMY_ERROR (  const err_t &    theError )

const vector<string> fileTags (  stringTags   , &    stringTags[INVALID] )

bool forceToTorque (  const DistanceResults &    results, std::list< Primitive * > &    armPrimitives, std::list< Primitive * > &    enviPrimitives, Vector &    torque )

Computes the torques on joints from forces acting on a robot. Parameters: const  DistanceResults& results A distance results object where both the distances, forces, and g functions for the distances have been calculated for a particular robot. This object MUST contain all the information needed between all primitive pairs for which the torques must be calculated. std::list<Primitive*>&  armPrimitives A list of primitive contained in the robot arm. std::list<Primitive*>&  enviPrimitives A list of primitive contained in the robot's environment. Vector&  torque Where the final torque will be stored. Returns true upon completion, false if there is an error (g functions for a primtiive pair aren't found, etc).

bool forceToTorque (  const Tensor &    gDist, const Matrix &    forces, Vector &    torque )

Computes torques on joints from forces acting on a robot, given the G funtions for the points of force. Parameters: gDist  Tensor of dimension (a x b x c), holding the G functions of the points acted upon by the forces forces  Matrix of dimension (a x c), holding the forces acting upon the robot torque  Vector of length (c), to hold computed torques Returns: true - succcess, false if parameter dimensions are incorrrect

bool forceToTorqueD1 (  const std::vector< Tensor * > &    hDist, const Tensor &    gDist, const Matrix &    forces, const Matrix &    forcesD1, const Vector &    jointVel, const Vector &    torques, Vector &    torquesD1 )

Computes derivative of torques on joints from forces acting on a robot. Parameters: hDist  Array(a), of pointers to Tensors(b x c x c), holding the H functions of the points acted upon by the forces gDist  Tensor(a x b x c), holding the g functions of the points acted upon by the forces forces  Matrix of dimension (a x b), holding the forces acting upon the robot forcesD1  Matrix of dimension (a x b), holding the forces acting upon the robot jointVel  Vector of length (c), holding the velocities of the joints torques  Vector of length (c), to hold computed torques torquesD1  Vector of length (c), to hold computed torques Returns: true - succcess, false if parameter dimensions are incorrrect

OSCARError fromException (  const SAXParseException &    toCatch )

OSCARError fromException (  const XMLException &    toCatch )

OSCARError fromException (  const DOMException &    toCatch )

OSCARError operator+ (  const OSCARError &    e1, const OSCARError &    e2 )

Overloaded operator+. This overloaded operator+ is used to add the individual elements of OSCARError objects. The integer error codes get added. The Basic Description text Strings get concatenated, and the custom description text Strings also get concatenated. This operator is also defined as extern so that it can be defined in multiple files. Parameters: e1  The OSCARError object on the left of the + operator to be added to. e2  The OSCARError object on the right of the + operator to be added. Returns: An OSCARError object that holds the results of the addition.

std::ostream& operator<< (  std::ostream &    out, const ObAvData &    arg )

std::ostream& operator<< (  std::ostream &    strm, const Tensor &    t )

std::ostream& operator<< (  std::ostream &    out, const MatrixCol &    m )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output MatrixCol objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. m  An MatrixCol object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    out, const MatrixRow &    m )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output MatrixRow objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. m  An MatrixRow object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    out, const Matrix &    m )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output Matrix objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. m  An Matrix object to be outputted. Returns: A reference to the output stream.

template<class Type> std::ostream& operator<< (  std::ostream &    os, const Array< Type > &    a )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output Array<Type> objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: os  An output stream. a  An Array<Type> object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    out, const TensorData &    T )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output TensorData objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. T  An TensorData object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    out, const MatrixData &    M )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output MatrixData objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. M  An MatrixData object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    out, const DHData &    D )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output DHData objects to an output stream. This operator<< is also defined as extern so that it can be defined in multiple files. Parameters: out  An output stream. D  An DHData object to be outputted. Returns: A reference to the output stream.

std::ostream& operator<< (  std::ostream &    strm, const OSCARError &    err )

Overloaded ostream operator<<. This overloaded ostream operator<< is used to output OSCARError objects to an output stream. This operator is also defined as extern so that it can be defined in multiple files. Parameters: strm  An output stream. err  An OSCARError object to be outputted. Returns: A reference to the output stream.

std::istream& operator>> (  std::istream &    is, bool &    b )

Overloaded istream operator>>. This overloaded istream operator>> is used to input Array<Type> objects, and the value of the istream is determined and based on that if it is >= 1, b is set to True. Otherwise, in the case of <1, it is set to False. Parameters: is  An input stream. b  A boolean value of True or False. Returns: A reference to the input stream.

template<class Type> std::istream& operator>> (  std::istream &    is, Array< Type > &    a )

Overloaded istream operator>>. This overloaded istream operator>> is used to input Array<Type> objects from an input stream. This operator>> is also defined as extern so that it can be defined in multiple files. Parameters: is  An input stream. a  An Array<Type> object to be input. Returns: A reference to the input stream.

double testEndPoints (  const Vector3 &    a0, const Vector3 &    a1, const Vector3 &    b0, const Vector3 &    b1, Vector3 &    aWit, Vector3 &    bWit, Vector3 &    unitVec, double &    t0, double &    t1 )

Called by LineLine in case the lines are parallel or if (t0,t1) < 0 or (t0,t1) > 1.

bool torqToEEWrench (  const Vector &    torques, const Matrix &    jacobInv, Vector &    eeForce )

Calculate end-effector forces based upon the joint torques and jabobian (pseudo-)inverse. Parameters: torques  Vector(DOF) containing joint torques jacobInv  Matrix(DOF x Outputs) containing the inverse/pseudo-inverse of the Jabobian eeForce  Vector(Outputs) to hold the end-effector forces Returns: true - success, false if parameter dimensions are incorrect

bool torqToEEWrenchD1 (  const Tensor &    eeTransHFunc, const Tensor &    eeRotHFunc, const Matrix &    jacobianInv, const Vector &    jointVel, const Vector &    torques, const Vector &    torquesD1, const Vector &    eeForce, Vector &    eeForceD1 )

Computes derivative of end-effector forces from joint torques. Parameters: eeTransHFunc  Tensor(a x b x a), holding the H functions of the points acted upon by the forces eeRotHFunc  Tensor(a x c x a), holding the g functions of the points acted upon by the forces jacobianInv  Matrix((b+c) x a), the inverse or pseudo-inverse of the Jacobian jointVel  Vector of length (a), holding the velocities of the joints torques  Vector of length (a), to hold computed torques torquesD1  Vector of length (a), to hold computed torques eeForce  Vector(b+c) of the end-effector forces eeForceD1  Vector(b+c) to hold the derivative of end-effector forces Returns: true - succcess, false if parameter dimensions are incorrrect

---

Variable Documentation

const double OSCAR::AngleTolerance = 0.00005

(radians) used for tolerances in handpose to rotation matrix calculations

const Control8Bit OSCAR::AutoHome = 0x50

const ADDR STATUS OSCAR::BYTE = 0x170

const float OSCAR::CmdDegPerSecPerCnt

Initial value: { 0.03449620F, 0.00332365F, 0.00689923F, 0.00449403F, 0.00862404F, 0.01403995F, 0.01149872F, 1.0F, 1.0F, 1.0F, 0.03449620F, 0.00332365F, 0.00689923F, 0.00449403F, 0.00862404F, 0.01403995F, 0.01149872F }

const float OSCAR::CmdFtlbPerCount

Initial value: { 0.01989355F, 0.02442972F, 0.00322281F, 0.00291611F, 0.00110578F, 0.00132393F, 0.00102124F, 1.0F, 1.0F, 1.0F, 0.01989355F, 0.02442972F, 0.00322281F, 0.00291611F, 0.00110578F, 0.00132393F, 0.00102124F}

const ADDR CURRENT OSCAR::COMMAND = 0x008

const float OSCAR::countsPerRadian

Initial value: { 208607.57F, 216513.79F, 104303.78F, 160127.17F, -83443.027F,-51254.879F, 62582.270F, 365063.24F, 342804.82F, 208607.57F, 208607.57F, 216513.79F, 104303.78F, 160127.17F, -83443.027F,-51254.879F, 62582.270F }

const float OSCAR::defaultExcessError = 10.0F * (float)DegToRad

const float OSCAR::defaultPositionLoopGains = 0.67F

const double OSCAR::DegToRad = PI/180.

const double OSCAR::Epsilon = 0.00001

const ADDR EXCESS OSCAR::ERROR = 0x120

const float OSCAR::FBCntPerDegPerSec

Initial value: { 10.1034667F, 10.4863881F, 5.05173333F, 7.75421010F, 4.04138667F, 2.48242176F,3.03104000F, 1.0F, 1.0F, 1.0F, 10.1034667F, 10.4863881F, 5.05173333F, 7.75421010F, 4.04138667F, 2.48242176F,3.03104000F}

const float OSCAR::FBcountsPerFtlb

Initial value: { 2.801664F, 4.767744F, 18.06336F, 20.103168F, 48.90624F, 39.591936F, 56.03328F, 1.0F, 1.0F, 1.0F, 2.801664F, 4.767744F, 18.06336F, 20.103168F, 48.90624F, 39.591936F, 56.03328F }

const ADDR SERVO INTERFACE OSCAR::FLAG = 0x216

const ADDR POS LOOP OSCAR::GAIN = 0x0d0

const Control8Bit OSCAR::J10CCK = 0x14

const Control8Bit OSCAR::J10CK = 0x13

const Control8Bit OSCAR::J11CCK = 0x16

const Control8Bit OSCAR::J11CK = 0x15

const Control8Bit OSCAR::J12CCK = 0x18

const Control8Bit OSCAR::J12CK = 0x17

const Control8Bit OSCAR::J13CCK = 0x1a

const Control8Bit OSCAR::J13CK = 0x19

const Control8Bit OSCAR::J14CCK = 0x1c

const Control8Bit OSCAR::J14CK = 0x1b

const Control8Bit OSCAR::J15CCK = 0x1e

const Control8Bit OSCAR::J15CK = 0x1d

const Control8Bit OSCAR::J16CCK = 0x20

const Control8Bit OSCAR::J16CK = 0x1f

const Control8Bit OSCAR::J17CCK = 0x22

const Control8Bit OSCAR::J17CK = 0x21

const Control8Bit OSCAR::J1CCK = 0x02

const Control8Bit OSCAR::J1CK = 0x01

const Control8Bit OSCAR::J2CCK = 0x04

const Control8Bit OSCAR::J2CK = 0x03

const Control8Bit OSCAR::J3CCK = 0x06

const Control8Bit OSCAR::J3CK = 0x05

const Control8Bit OSCAR::J4CCK = 0x08

const Control8Bit OSCAR::J4CK = 0x07

const Control8Bit OSCAR::J5CCK = 0x0a

const Control8Bit OSCAR::J5CK = 0x09

const Control8Bit OSCAR::J6CCK = 0x0c

const Control8Bit OSCAR::J6CK = 0x0b

const Control8Bit OSCAR::J7CCK = 0x0e

const Control8Bit OSCAR::J7CK = 0x0d

const Control8Bit OSCAR::J8CCK = 0x10

const Control8Bit OSCAR::J8CK = 0x0f

const Control8Bit OSCAR::J9CCK = 0x12

const Control8Bit OSCAR::J9CK = 0x11

const ADDR OSCAR::JOINTPOSITION = 0x218

const ADDR OSCAR::JOINTTORQUE = 0x290

const ADDR OSCAR::JOINTVELOCITY = 0x268

const unsigned int OSCAR::KB2017DOF = 17

const unsigned int OSCAR::LimitMatrixCol = 2

const ADDR DATA OSCAR::LOCK = 0x2c6

const ADDR INTERRUPT OSCAR::MASK = 0x2be

float OSCAR::MaxJointLimit

Initial value: { 179.0F*(float)DegToRad, 89.0F*(float)DegToRad, 179.0F*(float)DegToRad, 179.0F*(float)DegToRad, 350.0F*(float)DegToRad, 179.0F*(float)DegToRad, 350.0F*(float)DegToRad, 179.0F*(float)DegToRad, 29.0F*(float)DegToRad, 179.0F*(float)DegToRad, 179.0F*(float)DegToRad, 89.0F*(float)DegToRad, 179.0F*(float)DegToRad, 179.0F*(float)DegToRad, 350.0F*(float)DegToRad, 179.0F*(float)DegToRad, 350.0F*(float)DegToRad }

float OSCAR::MinJointLimit

Initial value: { -179.0F*(float)DegToRad, -89.0F*(float)DegToRad, -179.0F*(float)DegToRad, 1.0F*(float)DegToRad, -350.0F*(float)DegToRad, 1.0F*(float)DegToRad, -350.0F*(float)DegToRad, -179.0F*(float)DegToRad, -59.0F*(float)DegToRad, -179.0F*(float)DegToRad, -179.0F*(float)DegToRad, -89.0F*(float)DegToRad, -179.0F*(float)DegToRad, 1.0F*(float)DegToRad, -350.0F*(float)DegToRad, 1.0F*(float)DegToRad, -350.0F*(float)DegToRad }

const ADDR JOINT COM OSCAR::MODE = 0x176

const Control8Bit OSCAR::NullRobot = 0x30

const ADDR COM DIV OSCAR::NUMBER = 0x006

Control16Bit OSCAR::offset = {0x0024,0xff24,0x5fbb,0x746f,0x37ed,0xdf77,0x4b9d,0xef72,0x430e,0x835c,0x1d1d,0x54be,0x30ad,0xafda,0xe1a2,0xb9aa,0x0097}

const ADDR JOINT OSCAR::OFFSET = 0x0a8

const double OSCAR::PI = 3.14159265358979323846

const double OSCAR::RadToDeg = 180./PI

const unsigned int OSCAR::SizeControl16Bit = 2 [static]

const unsigned int OSCAR::SizeControl32Bit = 4 [static]

const unsigned int OSCAR::SizeControl8Bit = 1 [static]

const ADDR MACHINE OSCAR::START = 0x2ba

const ADDR COMMAND OSCAR::STATUS = 0x002

const string OSCAR::stringTags[] = {"ROBOT","BRANCH","OBSTACLE","SPHERE","CYLISPHERE","PLANE","BOX","RADIUS","FRAME","POINT","INVALID"}

const double OSCAR::Tiny = 1.0e-20

const double OSCAR::TwoPI = 2.*PI

const double OSCAR::TWOPI = 2.*PI

const ADDR MACHINE OSCAR::TYPE = 0x2c0

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations