sr_articulated_robot.h

Go to the documentation of this file.

#ifndef         SHADOWHAND_H_
# define        SHADOWHAND_H_

#include <ros/ros.h>
#include <string>
#include <vector>
#include <map>

#include <boost/smart_ptr.hpp>
#include <boost/thread.hpp>

#ifdef GAZEBO
#include <sensor_msgs/JointState.h>
#endif

namespace shadowrobot
{
struct JointData
{
    double position;
    double target;
    double temperature;
    double current;
    double force;
    std::string flags;
    int jointIndex;
    double min;
    double max;
    short isJointZero;
#ifdef GAZEBO

    int publisher_index;
#endif
    ros::Time last_pos_time;
    double last_pos;
    double velocity;



#ifdef GAZEBO
    JointData() :
        position(0.0), target(0.0), temperature(0.0), current(0.0), force(0.0), flags(""), jointIndex(0), min(0.0), max(90.0), isJointZero(0), publisher_index(0), last_pos_time(0.0), last_pos(0.0), velocity(0.0)
    {
    }

    JointData(JointData& jd) :
    position(jd.position), target(jd.target), temperature(jd.temperature), current(jd.current), force(jd.force),
            flags(jd.flags), jointIndex(jd.jointIndex), min(jd.min), max(jd.max), isJointZero(jd.isJointZero), publisher_index(jd.publisher_index), last_pos_time(jd.last_pos_time), last_pos(jd.last_pos), velocity(jd.velocity)
    {
    }

    JointData(const JointData& jd) :
    position(jd.position), target(jd.target), temperature(jd.temperature), current(jd.current), force(jd.force),
            flags(jd.flags), jointIndex(jd.jointIndex), min(jd.min), max(jd.max), isJointZero(jd.isJointZero), publisher_index(jd.publisher_index), last_pos_time(jd.last_pos_time), last_pos(jd.last_pos), velocity(jd.velocity)
    {
    }
#else
    JointData() :
        position(0.0), target(0.0), temperature(0.0), current(0.0), force(0.0), flags(""), jointIndex(0), min(0.0), max(90.0), isJointZero(0), last_pos_time(0.0), last_pos(0.0), velocity(0.0)
    {
    }

    JointData( JointData& jd ) :
        position(jd.position), target(jd.target), temperature(jd.temperature), current(jd.current), force(jd.force), flags(jd.flags), jointIndex(jd.jointIndex), min(jd.min), max(jd.max),
                isJointZero(jd.isJointZero), last_pos_time(jd.last_pos_time), last_pos(jd.last_pos), velocity(jd.velocity)
    {
    }

    JointData( const JointData& jd ) :
        position(jd.position), target(jd.target), temperature(jd.temperature), current(jd.current), force(jd.force), flags(jd.flags), jointIndex(jd.jointIndex), min(jd.min), max(jd.max),
                isJointZero(jd.isJointZero), last_pos_time(jd.last_pos_time), last_pos(jd.last_pos), velocity(jd.velocity)
    {
    }
#endif

};

enum controller_parameters
{
    PARAM_sensor, 
    PARAM_target, 
    PARAM_valve, 
    PARAM_deadband, 
    PARAM_p, 
    PARAM_i, 
    PARAM_d, 
    PARAM_imax, 
    PARAM_output_offset, 
    PARAM_shift, 
    PARAM_output_max, 

    PARAM_motor_maxforce, 
    PARAM_motor_safeforce, 
    PARAM_force_p, 
    PARAM_force_i, 
    PARAM_force_d, 
    PARAM_force_imax, 
    PARAM_force_out_shift, 
    PARAM_force_deadband, 
    PARAM_force_offset, 
    PARAM_sensor_imax, 
    PARAM_sensor_out_shift,
    PARAM_sensor_deadband, 
    PARAM_sensor_offset, 
    PARAM_max_temperature, 
    PARAM_max_current, 
    PARAM_type_of_sensor, 
    PARAM_type_of_setpoint

};

struct Parameters
{
    std::string name;
    std::string value;

    Parameters() :
        name(""), value("")
    {
    }

    Parameters( Parameters& param ) :
        name(param.name), value(param.value)
    {
    }

    Parameters( const Parameters& param ) :
        name(param.name), value(param.value)
    {
    }
};

struct JointControllerData
{
    std::vector<Parameters> data;

    JointControllerData() :
        data()
    {
    }

    JointControllerData( JointControllerData& jcd ) :
        data(jcd.data)
    {
    }

    JointControllerData( const JointControllerData& jcd ) :
        data(jcd.data)
    {
    }
};

struct DiagnosticData
{
    std::string joint_name;
    short level;

    std::string flags;

    int target_sensor_num;
    double target;

    int position_sensor_num;
    double position;

    double temperature;
    double current;
    double force;
};

class SRArticulatedRobot
{
public:
    SRArticulatedRobot()
    {
    }
    ;

    ~SRArticulatedRobot()
    {
    }
    ;

    typedef std::map<std::string, JointData> JointsMap;
    typedef std::map<std::string, enum controller_parameters> ParametersMap;

    virtual short sendupdate( std::string joint_name, double target ) = 0;

    virtual JointData getJointData( std::string joint_name ) = 0;

    virtual JointsMap getAllJointsData() = 0;

    virtual short setContrl( std::string contrlr_name, JointControllerData ctrlr_data ) = 0;

    virtual JointControllerData getContrl( std::string contrlr_name ) = 0;

    virtual short setConfig( std::vector<std::string> myConfig ) = 0;

    virtual void getConfig( std::string joint_name ) = 0;

    virtual std::vector<DiagnosticData> getDiagnostics() = 0;

    JointsMap joints_map;

    ParametersMap parameters_map;

    boost::mutex joints_map_mutex;
    boost::mutex parameters_map_mutex;
    boost::mutex controllers_map_mutex;

protected:

#ifdef GAZEBO
    std::vector<ros::Publisher> gazebo_publishers;
    ros::Subscriber gazebo_subscriber;
#endif
}; //end class

}//end namespace

#endif      /* !SHADOWHAND_H_ */

---

sr_hand
Author(s): Ugo Cupcic / ugo@shadowrobot.com, contact@shadowrobot.com
autogenerated on Fri Jan 11 09:32:55 2013