tibi_dabo_tts_client_alg_node.cpp

Go to the documentation of this file.

#include "tibi_dabo_tts_client_alg_node.h"

TibiDaboTtsClientAlgNode::TibiDaboTtsClientAlgNode(void) :
  algorithm_base::IriBaseAlgorithm<TibiDaboTtsClientAlgorithm>()
{
 //init class attributes if necessary
  this->loop_rate_ = 100;//in [Hz]

  // [init publishers]
  facial_expression_publisher_ = public_node_handle_.advertise<std_msgs::String>("facial_expression", 100);
  // [init subscribers]
  
  // [init services]
  
  // [init clients]
  
  // [init action servers]
  
  // [init action clients]
  this->tts_.client=new TtsClient("tts", true),
  this->tts_.active=false;
  this->tts_.succeeded=false;
  this->tts_.loaded=false;
  this->tts_.percentage=0.0;
  
  tts_connected_ = false;
}

TibiDaboTtsClientAlgNode::~TibiDaboTtsClientAlgNode(void)
{
  // [free dynamic memory]
  alg_.lock();
  this->cancelCurrentGoals();
  delete this->tts_.client;
  alg_.unlock();
}

void TibiDaboTtsClientAlgNode::cancelCurrentGoals(void)
{
  alg_.lock();
  if(this->tts_.client->isServerConnected() && this->tts_.loaded && this->tts_.active )
    this->tts_.client->cancelGoal();
  alg_.unlock();
}

void TibiDaboTtsClientAlgNode::speak(void)
{
  static int count = 0;
  std_msgs::String msg;
 
  if(count==0)
  {
    count=rand() % 200 + 200;
    msg.data = "speak";
    facial_expression_publisher_.publish(msg);
  }
  else 
  {
    count-=10;
    if(count<0) count=0;
  }
}

void TibiDaboTtsClientAlgNode::mainNodeThread(void)
{
  iri_common_drivers_msgs::ttsGoal tts_goal;
//  alg_.lock();
  tts_connected_ = true;

  // update client actions state
  tts_.client->waitForServer(ros::Duration(1.0));
  if(!this->tts_.client->isServerConnected())
  {
    tts_connected_ = false;
  }
  
  if( tts_connected_ )
  {
    if(this->tts_.active)
      this->speak();
    else
    {
      tts_goal.msg = this->readInput();
      if(tts_goal.msg.size())
      {
        ttsMakeActionRequest(tts_goal);
        this->tts_.loaded=true;
      }
    }
  }
  
//  alg_.unlock();
  
  // [fill msg structures]
  
  // [fill srv structure and make request to the server]
  
  // [fill action structure and make request to the action server]

  // [publish messages]
}

/*  [subscriber callbacks] */

/*  [service callbacks] */

/*  [action callbacks] */

/*  [action requests] */

//   Loquendo TTS Action Client

void TibiDaboTtsClientAlgNode::ttsDone(const actionlib::SimpleClientGoalState& state,
                                 const iri_common_drivers_msgs::ttsResultConstPtr& result) 
{
  std_msgs::String expression;

  alg_.lock();

  ROS_INFO("TibiDaboTtsClientAlgNode::ttsDone: Goal Achieved!"); 
  ROS_INFO("TibiDaboTtsClientAlgNode::ttsDone: state=%s", state.toString().c_str()); 

  if( state.state_ == actionlib::SimpleClientGoalState::SUCCEEDED )
    this->tts_.succeeded=true;
  else 
    this->tts_.succeeded=false;
    
  this->tts_.active=false;
  expression.data="stand_by";
  this->facial_expression_publisher_.publish(expression);

  alg_.unlock();
} 

void TibiDaboTtsClientAlgNode::ttsActive(void) 
{ 
  ROS_INFO("TibiDaboTtsClientAlgNode::ttsActive: Goal just went active!"); 
} 

void TibiDaboTtsClientAlgNode::ttsFeedback(const iri_common_drivers_msgs::ttsFeedbackConstPtr& feedback) 
{
  //ROS_INFO("TibiDaboTtsClientAlgNode::ttsFeedback: Got Feedback!"); 
  alg_.lock();
  if(feedback->busy)
    this->tts_.percentage=0.0;
  else
    this->tts_.percentage=100.0;
  alg_.unlock();
  ROS_INFO("TibiDaboTtsClientAlgNode::ttsFeedback: busy=%d", feedback->busy); 
}

void TibiDaboTtsClientAlgNode::ttsMakeActionRequest(const iri_common_drivers_msgs::ttsGoal & tts_goal)
{
  ROS_INFO("TibiDaboTtsClientAlgNode::ttsMakeActionRequest: Starting New Request!"); 

  //wait for the action server to start 
  //will wait for infinite time 
  this->tts_.client->waitForServer();  
  ROS_DEBUG("TibiDaboTtsClientAlgNode::ttsMakeActionRequest: TTS Server is Available!"); 

  //send a goal to the action 
  tts_.client->sendGoal(tts_goal, 
             boost::bind(&TibiDaboTtsClientAlgNode::ttsDone,     this, _1, _2), 
             boost::bind(&TibiDaboTtsClientAlgNode::ttsActive,   this), 
             boost::bind(&TibiDaboTtsClientAlgNode::ttsFeedback, this, _1)); 
  
  this->tts_.active=true;
}

std::string TibiDaboTtsClientAlgNode::readInput()
{
  ROS_INFO("Enter sentence: ");
  std::string input;
  getline( std::cin, input );
  ROS_INFO("You have entered: %s", input.c_str());
  return input;
}

void TibiDaboTtsClientAlgNode::node_config_update(Config &config, uint32_t level)
{
  this->alg_.lock();

  this->alg_.unlock();
}

void TibiDaboTtsClientAlgNode::addNodeDiagnostics(void)
{
}

/* main function */
int main(int argc,char *argv[])
{
  return algorithm_base::main<TibiDaboTtsClientAlgNode>(argc, argv, "tibi_dabo_tts_client_alg_node");
}