hlrc

/*

* This file is part of hlrc

*

* Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

* http://opensource.cit-ec.de/projects/hlrc

*

* This file may be licensed under the terms of the

* GNU General Public License Version 3 (the ``GPL''),

* or (at your option) any later version.

*

* Software distributed under the License is distributed

* on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

* express or implied. See the GPL for the specific language

* governing rights and limitations.

*

* You should have received a copy of the GPL along with this

* program. If not, go to http://www.gnu.org/licenses/gpl.html

* or write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*

* The development of this software was supported by the

* Excellence Cluster EXC 277 Cognitive Interaction Technology.

* The Excellence Cluster EXC 277 is a grant of the Deutsche

* Forschungsgemeinschaft (DFG) in the context of the German

* Excellence Initiative.

*

*/

#ifdef ROS_SUPPORT

#include "MiddlewareROS.h"

#include <stdio.h>

#include <boost/algorithm/string.hpp>

#include <boost/range/algorithm_ext/erase.hpp>

#include <boost/range/algorithm/remove_if.hpp>

using namespace std;

MiddlewareROS::MiddlewareROS(string scope) : Middleware(scope) {

    printf("> new MiddlewareROS() on base scope '%s'\n",base_scope.c_str());

    init();

}

template <typename actionspec>

actionlib::SimpleActionClient<actionspec> * create_action_client(string scope){

    printf("> starting SimpleActionClient on %s\n",scope.c_str());

    actionlib::SimpleActionClient<actionspec> *ac = new actionlib::SimpleActionClient<actionspec>(scope, true);

    if (!ac->waitForServer(ros::Duration(1))){

        char buf[256];

        snprintf(buf, 256, "ERROR: action service %s not ready", scope.c_str());

        throw runtime_error(buf);

    }

    return ac;

}

void MiddlewareROS::init(void){

    printf("> MiddlewareROS::init()\n");

    string scope = base_scope + "/set";

    string node_name = "hlrc_client__"+ base_scope;

    node_name.erase(boost::remove_if(node_name, boost::is_any_of("/")), node_name.end());

    printf("> registering on ROS as node %s, scope = %s\n",node_name.c_str(), scope.c_str());

    if (!ros::isInitialized()){

        ros::M_string no_remapping;

        ros::init(no_remapping, node_name);

    }

    //create node handle

    //ros_node_handle = new ros::NodeHandle();

    //node_handle = std::shared_ptr<ros::NodeHandle>(new ros::NodeHandle());

    printf("> setting up ROS action clients...\n");

    animation_ac = create_action_client<hlrc_server::animationAction>(scope + "/animation");

    utterance_ac = create_action_client<hlrc_server::utteranceAction>(scope + "/utterance");

    current_emotionstate_ac = create_action_client<hlrc_server::emotionstateAction>(scope + "/currentEmotion");

    default_emotionstate_ac = create_action_client<hlrc_server::emotionstateAction>(scope + "/defaultEmotion");

    gazetarget_ac = create_action_client<hlrc_server::gazetargetAction>(scope + "/gaze");

    lookattarget_ac = create_action_client<hlrc_server::lookattargetAction>(scope + "/lookat");

    mouthtarget_ac = create_action_client<hlrc_server::mouthtargetAction>(scope + "/mouth");

    speech_ac = create_action_client<hlrc_server::speechAction>(scope + "/speech");

    printf("> init done.\n");

}

void MiddlewareROS::publish_emotion(string scope_target, RobotEmotion e, bool blocking){

    hlrc_server::emotionstateGoal goal;

    switch(e.value){

        default:

            printf("> WANRING: invalid emotion id %d. defaulting to NEUTRAL\n",e.value);

            //fall through:

        case(RobotEmotion::NEUTRAL):

            goal.value = hlrc_server::emotionstateGoal::NEUTRAL;

            break;

        case(RobotEmotion::HAPPY):

            goal.value = hlrc_server::emotionstateGoal::HAPPY;

            break;

        case(RobotEmotion::SAD):

            goal.value = hlrc_server::emotionstateGoal::SAD;

            break;

        case(RobotEmotion::ANGRY):

            goal.value = hlrc_server::emotionstateGoal::ANGRY;

            break;

        case(RobotEmotion::SURPRISED):

            goal.value = hlrc_server::emotionstateGoal::SURPRISED;

            break;

        case(RobotEmotion::FEAR):

            goal.value = hlrc_server::emotionstateGoal::FEAR;

            break;

    }

    goal.duration = e.time_ms;

    actionlib::SimpleActionClient<hlrc_server::emotionstateAction>  *ac;

    if (scope_target == "defaultEmotion"){

        ac = default_emotionstate_ac;

    }else{

        ac = current_emotionstate_ac;

    }

    //send

    ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

void MiddlewareROS::publish_current_emotion(RobotEmotion e, bool blocking){

    publish_emotion("currentEmotion", e, blocking);

}

void MiddlewareROS::publish_default_emotion(RobotEmotion e, bool blocking){

    publish_emotion("defaultEmotion", e, blocking);

}

void MiddlewareROS::publish_gaze_target(RobotGaze target, bool blocking){

    hlrc_server::gazetargetGoal goal;

    goal.pan = target.pan;

    goal.tilt = target.tilt;

    goal.roll = target.roll;

    goal.vergence = target.vergence;

    goal.tilt_offset = target.tilt_offset;

    goal.pan_offset = target.pan_offset;

    //timestamp:

    goal.gaze_timestamp.sec  = target.gaze_timestamp.sec;

    goal.gaze_timestamp.nsec = target.gaze_timestamp.nsec;

    if (target.gaze_type == RobotGaze::ABSOLUTE){

        goal.gaze_type = hlrc_server::gazetargetGoal::GAZETARGET_ABSOLUTE;

    }else{

        goal.gaze_type = hlrc_server::gazetargetGoal::GAZETARGET_RELATIVE;

    }

    //send

    gazetarget_ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = gazetarget_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

void MiddlewareROS::publish_lookat_target(float x, float y, float z, const string frame_id, bool blocking, float roll)

{

    hlrc_server::lookattargetGoal goal;

    goal.point.header.frame_id = frame_id;

    goal.point.header.stamp = ros::Time::now();

    geometry_msgs::Point &p = goal.point.point;

    p.x = x;

    p.y = y;

    p.z = z;

    goal.roll = roll;

    //send

    lookattarget_ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = gazetarget_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

void MiddlewareROS::publish_mouth_target(RobotMouth target, bool blocking){

    hlrc_server::mouthtargetGoal goal;

    goal.position_left   = target.position_left;

    goal.position_center = target.position_center;

    goal.position_right  = target.position_right;

    goal.opening_left   = target.opening_left;

    goal.opening_center = target.opening_center;

    goal.opening_right  = target.opening_right;

    //send

    mouthtarget_ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = mouthtarget_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

void MiddlewareROS::publish_head_animation(RobotHeadAnimation a, bool blocking){

    hlrc_server::animationGoal goal;

    switch(a.value){

        default:

            printf("> WANRING: invalid animation id %d. defaulting to IDLE",a.value);

            //fall through:

        case(RobotHeadAnimation::IDLE):

            goal.target = hlrc_server::animationGoal::IDLE;

            break;

        case(RobotHeadAnimation::HEAD_NOD):

            goal.target = hlrc_server::animationGoal::HEAD_NOD;

            break;

        case(RobotHeadAnimation::HEAD_SHAKE):

            goal.target = hlrc_server::animationGoal::HEAD_SHAKE;

            break;

        case(RobotHeadAnimation::EYEBLINK_L):

            goal.target = hlrc_server::animationGoal::EYEBLINK_L;

            break;

        case(RobotHeadAnimation::EYEBLINK_R):

            goal.target = hlrc_server::animationGoal::EYEBLINK_R;

            break;

        case(RobotHeadAnimation::EYEBLINK_BOTH):

            goal.target = hlrc_server::animationGoal::EYEBLINK_BOTH;

            break;

        case(RobotHeadAnimation::EYEBROWS_RAISE):

            goal.target = hlrc_server::animationGoal::EYEBROWS_RAISE;

            break;

        case(RobotHeadAnimation::EYEBROWS_LOWER):

            goal.target = hlrc_server::animationGoal::EYEBROWS_LOWER;

            break;

    }

    goal.repetitions = a.repetitions;

    goal.scale       = a.scale;

    goal.duration_each = a.time_ms;

    //send

    animation_ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = animation_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

void MiddlewareROS::publish_speech(string text, bool blocking){

    hlrc_server::speechGoal goal;

    goal.text = text;

    //send

    speech_ac->sendGoal(goal);

    if (blocking){

        bool finished_before_timeout = speech_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

        if (!finished_before_timeout){

            printf("> ERROR: blocking call timed out!\n");

        }

    }

}

#endif