tibi_dabo_questions_server_alg_node.cpp

Go to the documentation of this file.

#include "tibi_dabo_questions_server_alg_node.h"

TibiDaboQuestionsServerAlgNode::TibiDaboQuestionsServerAlgNode(void) :
  algorithm_base::IriBaseAlgorithm<TibiDaboQuestionsServerAlgorithm>(),
  voice_recognition_aserver_(public_node_handle_, "voice_recognition")
{
  //init class attributes if necessary
  //this->loop_rate_ = 2;//in [Hz]
  ros::NodeHandle private_node_handle("~");
  private_node_handle.param<std::string>("filePath", filePath_, "");
  this->alg_.setFilePath(filePath_);
  this->start_=false;
  this->done_=false;
  this->alg_.initialize();

  // [init publishers]
  
  // [init subscribers]
  
  // [init services]
  
  // [init clients]
  
  // [init action servers]
  voice_recognition_aserver_.registerStartCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionStartCallback, this, _1)); 
  voice_recognition_aserver_.registerStopCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionStopCallback, this)); 
  voice_recognition_aserver_.registerIsFinishedCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionIsFinishedCallback, this)); 
  voice_recognition_aserver_.registerHasSucceedCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionHasSucceedCallback, this)); 
  voice_recognition_aserver_.registerGetResultCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionGetResultCallback, this, _1)); 
  voice_recognition_aserver_.registerGetFeedbackCallback(boost::bind(&TibiDaboQuestionsServerAlgNode::voice_recognitionGetFeedbackCallback, this, _1)); 
  voice_recognition_aserver_.start();
  
  // [init action clients]
}

TibiDaboQuestionsServerAlgNode::~TibiDaboQuestionsServerAlgNode(void)
{
  // [free dynamic memory]
  this->alg_.finalize();
}

void TibiDaboQuestionsServerAlgNode::mainNodeThread(void)
{
  if(this->start_)
  {
    this->answer_ = this->alg_.iteration();
    this->done_=true;
    this->start_=false;
  }
  // [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] */
void TibiDaboQuestionsServerAlgNode::voice_recognitionStartCallback(const iri_perception_msgs::voiceRecognitionGoalConstPtr& goal)
{ 
  ROS_INFO("voice_recognitionStartCallback");
  alg_.lock(); 
    //check goal 
    //execute goal
    startTask();
    this->start_=true;
  alg_.unlock(); 
} 

void TibiDaboQuestionsServerAlgNode::voice_recognitionStopCallback(void) 
{
  ROS_INFO("voice_recognitionStopCallback");
  alg_.lock(); 
    //stop action
    stopTask();
    this->start_=false;
  alg_.unlock(); 
} 

bool TibiDaboQuestionsServerAlgNode::voice_recognitionIsFinishedCallback(void) 
{
  //ROS_INFO("voice_recognitionIsFinishedCallback");
  bool ret = false; 

  alg_.lock(); 
    //if action has finish for any reason
     if( this->done_ || !this->start_)
     {
       ret = true;
     }
  alg_.unlock(); 

  return ret; 
} 

bool TibiDaboQuestionsServerAlgNode::voice_recognitionHasSucceedCallback(void) 
{ 
  ROS_INFO("voice_recognitionHasSucceedCallback");
  bool ret = false; 

  alg_.lock(); 
    //if goal was accomplished
    //if( (this->alg_.answerCode_ != 0 ) && this->status_==0)
    if(this->done_)
    {
      ret = true;
      this->done_=false;
    }
  alg_.unlock(); 

  return ret; 
} 

void TibiDaboQuestionsServerAlgNode::voice_recognitionGetResultCallback(iri_perception_msgs::voiceRecognitionResultPtr& result) 
{
  ROS_INFO("voice_recognitionGetResultCallback");
  alg_.lock(); 
    //update result data to be sent to client 
    //result->data = data;
    //Return answer string and related int code
    result->answer = this->answer_;
    this->answer_.clear();
    result->code   = this->alg_.answerCode_;
    this->alg_.answerCode_ = 0;
    this->start_=false;
  alg_.unlock(); 
} 

void TibiDaboQuestionsServerAlgNode::voice_recognitionGetFeedbackCallback(iri_perception_msgs::voiceRecognitionFeedbackPtr& feedback) 
{
  //ROS_INFO("voice_recognitionGetFeedbackCallback");
  alg_.lock(); 
    //keep track of feedback 
    //ROS_INFO("feedback: %s", feedback->data.c_str());
    //Track status int
    this->status_ = getStatus();
    feedback->status = this->status_;
    //feedback->noise  = getNoise();
  alg_.unlock(); 
}

/*  [action requests] */

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

  this->alg_.unlock();
}

void TibiDaboQuestionsServerAlgNode::addNodeDiagnostics(void)
{
}

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