sdh.h

Go to the documentation of this file.

//======================================================================
//======================================================================
 
#ifndef SDH_h_
#define SDH_h_
 
#include "sdhlibrary_settings.h"
 
#if SDH_USE_VCC
# pragma warning(disable : 4996)
#else
// must be included first on some linuxes
extern "C" {
# include <stdint.h>
}
#endif
 
#include "basisdef.h"
 
  //----------------------------------------------------------------------
// System Includes - include with <>
//----------------------------------------------------------------------
 
#include <vector>
#include <string>
 
//----------------------------------------------------------------------
// Project Includes - include with ""
//----------------------------------------------------------------------
 
#include "sdhbase.h"
#include "sdhserial.h"
#include "unit_converter.h"
#include "serialbase.h"
 
//----------------------------------------------------------------------
// Defines, enums, unions, structs
//----------------------------------------------------------------------
 
#if SDH_USE_NAMESPACE
 
#endif
 
NAMESPACE_SDH_START
 
//----------------------------------------------------------------------
// Global variables (declarations)
//----------------------------------------------------------------------
 
 
//----------------------------------------------------------------------
// External functions and classes (declarations)
//----------------------------------------------------------------------
 
 
//----------------------------------------------------------------------
// Function prototypes (function declarations)
//----------------------------------------------------------------------
 
 
//----------------------------------------------------------------------
// Class declarations
//----------------------------------------------------------------------
 
#if SDH_USE_VCC
// these are needed by VCC for template instantiation into a DLL,
// see http://support.microsoft.com/default.aspx?scid=kb;EN-US;q168958
// and http://www.unknownroad.com/rtfm/VisualStudio/warningC4251.html
//
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::allocator<int>;
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::vector<int,std::allocator<int> >;
 
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::allocator<std::vector<int> >;
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::vector<std::vector<int>,std::allocator<std::vector<int> > >;
 
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::allocator<double>;
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::vector<double,std::allocator<double> >;
 
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::allocator<std::vector<double> >;
VCC_EXPORT_TEMPLATE template class VCC_EXPORT std::vector<std::vector<double>,std::allocator<std::vector<double> > >;
#endif
 
//======================================================================
 
class VCC_EXPORT cSDH : public cSDHBase
{
public:
 
    enum eMotorCurrentMode
    {
        eMCM_MOVE=0, 
        eMCM_GRIP=1, 
        eMCM_HOLD=2, 
 
        eMCM_DIMENSION 
    };
 
 
    enum eAxisState
    {
        eAS_IDLE = 0,            
        eAS_POSITIONING,         
        eAS_SPEED_MODE,          
        eAS_NOT_INITIALIZED,     
        eAS_CW_BLOCKED,          
        eAS_CCW_BLOCKED,         
        eAS_DISABLED,            
        eAS_LIMITS_REACHED,      
 
        eAS_DIMENSION 
    };
 
 
    //#######################################################################
    static cUnitConverter const uc_angle_degrees;
 
    static cUnitConverter const uc_angle_radians;
 
    static cUnitConverter const uc_time_seconds;
 
    static cUnitConverter const uc_time_milliseconds;
 
    static cUnitConverter const uc_temperature_celsius;
 
    static cUnitConverter const uc_temperature_fahrenheit;
 
    static cUnitConverter const uc_angular_velocity_degrees_per_second;
 
    static cUnitConverter const uc_angular_velocity_radians_per_second;
 
    static cUnitConverter const uc_angular_acceleration_degrees_per_second_squared;
 
    static cUnitConverter const uc_angular_acceleration_radians_per_second_squared;
 
    static cUnitConverter const uc_motor_current_ampere;
 
    static cUnitConverter const uc_motor_current_milliampere;
 
    static cUnitConverter const uc_position_millimeter;
 
    static cUnitConverter const uc_position_meter;
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_unit_conversion_objects
 
protected:
    //---------------------
    // Misc member variables
 
    int NUMBER_OF_AXES_PER_FINGER;
 
 
    int NUMBER_OF_VIRTUAL_AXES;
 
    int nb_all_axes;
 
    std::vector<int> finger_number_of_axes;
 
 
    std::vector<std::vector<int> > finger_axis_index;
 
    //f_eps_v;
 
    std::vector<double> f_zeros_v;
 
    std::vector<double> f_ones_v;
 
 
    std::vector<double> zeros_v;
 
    std::vector<double> ones_v;
 
 
    std::vector<double> f_min_motor_current_v;
 
    std::vector<double> f_max_motor_current_v;
 
 
 
    std::vector<double> f_min_angle_v;
 
    std::vector<double> f_max_angle_v;
 
    std::vector<double> f_min_velocity_v;
 
    std::vector<double> f_max_velocity_v;
 
    std::vector<double> f_min_acceleration_v;
 
    std::vector<double> f_max_acceleration_v;
 
    double grip_max_velocity;
 
    double l1;
 
    double l2;
 
    // distance between center points of base joints f0<->f1, f1<->f2, f0<->f2
    double d;
 
    // height of center of base joints above finger base plate
    double h;
 
    std::vector<std::vector<double> > offset;
 
    cSerialBase* com;
 
    // !!! make this public for now (to access comm_interface->ref() / comm_interface->pos_save() for hands with missing absolute encoders)
public:
    cSDHSerial comm_interface;
 
    virtual void SetDebugOutput( std::ostream* debuglog )
    {
        cSDHBase::SetDebugOutput( debuglog );
        comm_interface.SetDebugOutput( debuglog );
    }
 
protected:
 
    //######################################################################
    //----------------------------------------------------------------------
    std::vector<double> SetAxisValueVector( std::vector<int> const& axes,
                                            std::vector<double> const& values,
                                            pSetFunction ll_set,
                                            pGetFunction ll_get,
                                            cUnitConverter const* uc,
                                            std::vector<double> const& min_values,
                                            std::vector<double> const& max_values,
                                            char const* name );
 
 
    //----------------------------------------------------------------------
    std::vector<double> GetAxisValueVector( std::vector<int> const& axes,
                                            pGetFunction ll_get,
                                            cUnitConverter const* uc,
                                            char const* name );
 
    //-----------------------------------------------------------------
    std::vector<int> ToIndexVector( int index, std::vector<int>& all_replacement, int maxindex, char const* name );
 
 
    //-----------------------------------------------------------------
    pSetFunction GetMotorCurrentModeFunction( eMotorCurrentMode mode );
 
 
    //-----------------------------------------------------------------
    std::vector<double> _GetFingerXYZ( int fi, std::vector<double> r_angles );
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_internal
    //#####################################################################
 
 
public:
    //----------------------------------------------------------------------
    std::vector<int> all_axes;
 
    std::vector<int> all_real_axes;
 
    std::vector<int> all_fingers;
 
    std::vector<int> all_temperature_sensors;
 
    //  end of sdhlibrary_cpp_sdh_h_index_vectors
    //----------------------------------------------------------------------
 
 
    //----------------------------------------------------------------------
    const cUnitConverter* uc_angle;
 
 
    const cUnitConverter* uc_angular_velocity;
 
 
    const cUnitConverter* uc_angular_acceleration;
 
 
    const cUnitConverter* uc_time;
 
 
    const cUnitConverter* uc_temperature;
 
 
    const cUnitConverter* uc_motor_current;
 
 
    const cUnitConverter* uc_position;
    //---------------------
 
    // end of sdhlibrary_cpp_sdh_h_unit_conversion_ptrs
    //----------------------------------------------------------------------
 
 
    //-----------------------------------------------------------------
    cSDH( bool _use_radians=false, bool _use_fahrenheit=false, int _debug_level=0 );
 
 
    //----------------------------------------------------------------------
    virtual ~cSDH();
 
 
    //######################################################################
    //----------------------------------------------------------------------
    bool IsVirtualAxis( int iAxis );
 
    //-----------------------------------------------------------------
    void UseRadians( void );
 
 
    //-----------------------------------------------------------------
    void UseDegrees( void );
 
 
    //-----------------------------------------------------------------
    int GetFingerNumberOfAxes( int iFinger );
 
 
    //-----------------------------------------------------------------
    int GetFingerAxisIndex( int iFinger, int iFingerAxis );
 
 
    //-----------------------------------------------------------------
    static char const* GetLibraryRelease( void );
 
 
    //-----------------------------------------------------------------
    static char const* GetLibraryName( void );
 
 
    //-----------------------------------------------------------------
    char const* GetFirmwareRelease( void );
 
    //-----------------------------------------------------------------
    static char const* GetFirmwareReleaseRecommended( void );
 
    //-----------------------------------------------------------------
    bool CheckFirmwareRelease( void );
 
    //-----------------------------------------------------------------
    char const* GetInfo( char const* what );
 
    //-----------------------------------------------------------------
    std::vector<double> GetTemperature( std::vector<int> const& sensors );
 
 
    //----------------------------------------------------------------------
    double GetTemperature( int iSensor );
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_common
    //#####################################################################
 
 
    //######################################################################
    //-----------------------------------------------------------------
    void OpenRS232(  int _port=0, unsigned long _baudrate = 115200, double _timeout=-1, char const* _device_format_string="/dev/ttyS%d" );
 
 
    void OpenCAN_ESD(  int _net=0,  unsigned long _baudrate=1000000, double _timeout=0.0, Int32 _id_read=43, Int32 _id_write=42 );
 
 
    void OpenCAN_ESD(  tDeviceHandle _ntcan_handle, double _timeout=0.0, Int32 _id_read=43, Int32 _id_write=42 );
 
 
    void OpenCAN_PEAK( unsigned long _baudrate=1000000, double _timeout=0.0, Int32 _id_read=43, Int32 _id_write=42, const char *_device="/dev/pcanusb0" );
 
 
    void OpenCAN_PEAK(  tDeviceHandle _handle, double _timeout=0.0, Int32 _id_read=43, Int32 _id_write=42 );
 
    void OpenTCP( char const* _tcp_adr="192.168.1.1", int _tcp_port=23, double _timeout=0.0 );
 
    //-----------------------------------------------------------------
    void Close( bool leave_enabled=false );
 
    //-----------------------------------------------------------------
    virtual bool IsOpen( void )
        throw ();
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_communication
    //#####################################################################
 
 
    //######################################################################
    //-----------------------------------------------------------------
    void EmergencyStop( void );
 
 
    //-----------------------------------------------------------------
    void Stop( void );
 
 
    //-----------------------------------------------------------------
    //-----------------------------------------------------------------
    // unimplemented from SAH:
    // def GetEmergencyStop( int* piBrakeState)
 
    //-----------------------------------------------------------------
    void SetController( cSDHBase::eControllerType controller );
 
    //-----------------------------------------------------------------
    eControllerType GetController( void  );
 
    //-----------------------------------------------------------------
    void SetVelocityProfile( eVelocityProfile velocity_profile );
 
 
    //-----------------------------------------------------------------
    eVelocityProfile GetVelocityProfile( void );
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_auxilliary
    //#####################################################################
 
 
    //######################################################################
    //-----------------------------------------------------------------
    void SetAxisMotorCurrent( std::vector<int> const& axes, std::vector<double> const& motor_currents, eMotorCurrentMode mode=eMCM_MOVE );
 
 
    //----------------------------------------------------------------------
    void SetAxisMotorCurrent( int iAxis, double motor_current, eMotorCurrentMode mode=eMCM_MOVE );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisMotorCurrent( std::vector<int> const& axes, eMotorCurrentMode mode=eMCM_MOVE );
 
 
    //----------------------------------------------------------------------
    double GetAxisMotorCurrent( int iAxis, eMotorCurrentMode mode=eMCM_MOVE );
 
 
    //-----------------------------------------------------------------
    void SetAxisEnable( std::vector<int> const& axes, std::vector<double> const& states );
 
 
    //----------------------------------------------------------------------
    void SetAxisEnable( int iAxis=All, double state=1.0 );
 
 
    //----------------------------------------------------------------------
    void SetAxisEnable( std::vector<int> const& axes, std::vector<bool> const& states );
 
 
    //----------------------------------------------------------------------
    void SetAxisEnable( int iAxis=All, bool state=true );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisEnable( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisEnable( int iAxis );
 
 
    //----------------------------------------------------------------------
    std::vector<eAxisState> GetAxisActualState( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    eAxisState GetAxisActualState( int iAxis );
 
 
    //-----------------------------------------------------------------
    void WaitAxis( std::vector<int> const& axes, double timeout = -1.0 );
 
 
 
    //----------------------------------------------------------------------
    void WaitAxis( int iAxis, double timeout = -1.0 );
 
 
    //----------------------------------------------------------------------
    void SetAxisTargetAngle( std::vector<int> const& axes, std::vector<double> const& angles );
 
 
    //----------------------------------------------------------------------
    void SetAxisTargetAngle( int iAxis, double angle );
 
 
    //----------------------------------------------------------------------
    std::vector<double> SetAxisTargetGetAxisActualAngle( std::vector<int> const& axes, std::vector<double> const& angles );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisTargetAngle( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisTargetAngle( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisActualAngle( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisActualAngle( int iAxis );
 
 
    //-----------------------------------------------------------------
    void SetAxisTargetVelocity( std::vector<int> const& axes, std::vector<double> const& velocities );
 
 
    //----------------------------------------------------------------------
    void SetAxisTargetVelocity( int iAxis, double velocity );
 
 
    //----------------------------------------------------------------------
    std::vector<double> SetAxisTargetGetAxisActualVelocity( std::vector<int> const& axes, std::vector<double> const& velocities );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisTargetVelocity( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisTargetVelocity( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisLimitVelocity( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisLimitVelocity( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisLimitAcceleration( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisLimitAcceleration( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisActualVelocity( std::vector<int>const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisActualVelocity( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisReferenceVelocity( std::vector<int>const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisReferenceVelocity( int iAxis );
 
 
    //-----------------------------------------------------------------
    void SetAxisTargetAcceleration( std::vector<int>const& axes, std::vector<double>const& accelerations );
 
 
    //----------------------------------------------------------------------
    void SetAxisTargetAcceleration( int iAxis, double acceleration );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisTargetAcceleration( std::vector<int>const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisTargetAcceleration( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisMinAngle( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisMinAngle( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisMaxAngle( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisMaxAngle( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisMaxVelocity( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisMaxVelocity( int iAxis );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetAxisMaxAcceleration( std::vector<int> const& axes );
 
 
    //----------------------------------------------------------------------
    double GetAxisMaxAcceleration( int iAxis );
 
 
    //-----------------------------------------------------------------
    double MoveAxis( std::vector<int>const& axes, bool sequ=true );
 
 
    //----------------------------------------------------------------------
    double MoveAxis( int iAxis, bool sequ=true );
 
 
    // unimplemented from SAH:
    // def GetJointAngle( int iFinger,double* pafAngle);
    // def GetJointSpeed( int iFinger,double* pafSpeed);
    // def GetJointTorque( int iFinger,double* pafTorque);
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_axis
    //#####################################################################
 
    //######################################################################
    //-----------------------------------------------------------------
    void SetFingerEnable( std::vector<int> const& fingers, std::vector<double> const& states );
 
 
    //----------------------------------------------------------------------
    void SetFingerEnable( int iFinger, double state=1.0 );
 
 
    //----------------------------------------------------------------------
    void SetFingerEnable( std::vector<int> const& fingers, std::vector<bool> const& states );
 
 
    //----------------------------------------------------------------------
    void SetFingerEnable( int iFinger, bool state );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerEnable( std::vector<int> const& fingers );
 
 
    //----------------------------------------------------------------------
    double GetFingerEnable( int iFinger );
 
 
    //-----------------------------------------------------------------
    void SetFingerTargetAngle( int iFinger, std::vector<double> const& angles );
 
 
    //-----------------------------------------------------------------
    void SetFingerTargetAngle( int iFinger, double a0, double a1, double a2 );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerTargetAngle( int iFinger );
 
 
    //-----------------------------------------------------------------
    void GetFingerTargetAngle( int iFinger, double& a0, double& a1, double& a2 );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerActualAngle( int iFinger );
 
 
    //-----------------------------------------------------------------
    void GetFingerActualAngle( int iFinger, double& a0, double& a1, double& a2 );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerMinAngle( int iFinger );
 
 
    //-----------------------------------------------------------------
    void GetFingerMinAngle( int iFinger, double& a0, double& a1, double& a2 );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerMaxAngle( int iFinger );
 
 
    //-----------------------------------------------------------------
    void GetFingerMaxAngle( int iFinger, double& a0, double& a1, double& a2 );
 
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerXYZ( int iFinger, std::vector<double> const& angles );
 
 
    //-----------------------------------------------------------------
    std::vector<double> GetFingerXYZ( int iFinger, double a0, double a1, double a2 );
 
 
    //-----------------------------------------------------------------
    double MoveFinger( std::vector<int>const& fingers, bool sequ=true );
 
 
    //----------------------------------------------------------------------
    double MoveFinger( int iFinger, bool sequ=true );
 
 
    //-----------------------------------------------------------------
    double MoveHand( bool sequ=true );
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_finger
    //#####################################################################
 
 
    //######################################################################
    //-----------------------------------------------------------------
    double GetGripMaxVelocity( void );
 
 
    //-----------------------------------------------------------------
    double GripHand( eGraspId grip, double close, double velocity, bool sequ=true );
 
 
    //  end of doxygen name group sdhlibrary_cpp_sdh_h_csdh_grip
    //#####################################################################
 
private:
    void UpdateSettingsFromSDH();
 
    void AdjustLimits( cSDHBase::eControllerType controller );
 
 
    std::string release_firmware;
 
    eControllerType controller_type;
 
    // unimplemented from SAH:
    // def GetFingerTipFT( int iFinger,double* pafFTData);
 
    // def GetFingerEnableState( int iFinger, int* piEnableState);
 
    // def GetCommandedValues( int iFinger, double* pafAngle,double* pafVelocity);
    // def GetHandConfig( int* piConfig);
    // def GetFingerLimitsStatus( int iPort,int iFinger,int* paiLimitStatus);
    // def ClearTorqueSensorOffset( int iPort,int iFinger);
 
    // def SetStiffnessFactor( int iFinger, double* pafStiffnessFactor);
 
 
 
}; // end of class cSDH
//#####################################################################
 
NAMESPACE_SDH_END
 
#endif
 
 
//======================================================================
/*
  Here are some settings for the emacs/xemacs editor (and can be safely ignored)
  (e.g. to explicitely set C++ mode for *.h header files)
 
  Local Variables:
  mode:C++
  mode:ELSE
  End:
*/
//======================================================================]