tibi_dabo_haod_alg_node.cpp

Go to the documentation of this file.

#include "tibi_dabo_haod_alg_node.h"
#include "wiimote/State.h"
#include <stdlib.h>

std::string catalan_speech[]={"\\language=Catalan \\voice=Montserrat Per començar selecciona una de les cares detectades a la imatge, i llavors em pots ajudar a millorar les meves deteccions",
                              "\\language=Catalan \\voice=Montserrat Ho sento, no puc detectar cap cara en aquest punt.", 
                              "\\language=Catalan \\voice=Montserrat Gracies per la teva ajuda. Adeu!",
                              "\\language=Catalan \\voice=Montserrat És correcte la detecció?",
                              "\\language=Catalan \\voice=Montserrat El rectangle blau està sobre la teva cara?",
                              "\\language=Catalan \\voice=Montserrat Corretgeix-me si estic equivocada",
                              "\\language=Catalan \\voice=Montserrat Tinc un dubte, digue'm si és correcte"};

std::string english_speech[]={"\\language=English \\voice=Kate To start select one of the faces detected in the image, and then you may help me improve my detections",
                              "\\language=English \\voice=Kate Sorry, I can not detect a face there.",
                              "\\language=English \\voice=Kate Thanks for your help. Bye!",
                              "\\language=English \\voice=Kate Is the detection correct?",
                              "\\language=English \\voice=Kate Is the blue rectangle on your face?",
                              "\\language=English \\voice=Kate Correct me if I'm wrong please.",
                              "\\language=English \\voice=Kate I have a doubt, tell me if is it correct?"};

std::string spanish_speech[]={"\\language=Spanish \\voice=Leonor Para empezar selecciona una de las caras detectadad en la imagen, y entonces me puedes ayudar a mejhorar mis detecciones",
                              "\\language=Spanish \\voice=Leonor Lo siento, no detecto ninguna cara en ese punto.", 
                              "\\language=Spanish \\voice=Leonor Gracias por tu ayuda. Adios!",
                              "\\language=Spanish \\voice=Leonor Es correta la detección?",
                              "\\language=Spanish \\voice=Leonor El rectangulo azul está sobre tu cara?",
                              "\\language=Spanish \\voice=Leonor Corrigeme si estoy equivocada.",
                              "\\language=Spanish \\voice=Leonor Tengo una duda, dime si es correcto."};

std::string head_motion[]={"",
                           "",
                           ""};

std::string left_arm_motion[]={"left_arm_home.xml",
                               "left_arm_home.xml",
                               "left_arm_home.xml"};

std::string right_arm_motion[]={"right_arm_home.xml",
                                "right_arm_home.xml",
                                "right_arm_home.xml"};

TibiDaboHaodAlgNode::TibiDaboHaodAlgNode(void) :
  algorithm_base::IriBaseAlgorithm<TibiDaboHaodAlgorithm>(),
  haod_server_aserver_(public_node_handle_, "haod_server"),
  hri_client_client_("hri_client", true),
  follow_target_client_("follow_target", true)
{
  //init class attributes if necessary
  this->loop_rate_ = 10;//in [Hz]

  // [init publishers]
  this->target_joints_publisher_ = this->public_node_handle_.advertise<trajectory_msgs::JointTrajectoryPoint>("target_joints", 10);
  
  // [init subscribers]
  this->joy_subscriber_ = this->public_node_handle_.subscribe("joy", 10, &TibiDaboHaodAlgNode::joy_callback, this);
  
  // [init services]
  
  // [init clients]
  haod_learn_client_ = this->public_node_handle_.serviceClient<iri_human_assisted_object_detection::haod_learn>("haod_learn");
  haod_detect_client_ = this->public_node_handle_.serviceClient<iri_human_assisted_object_detection::haod_detect>("haod_detect");
  haod_init_client_ = this->public_node_handle_.serviceClient<iri_human_assisted_object_detection::haod_init>("haod_init");
  
  // [init action servers]
  haod_server_aserver_.registerStartCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverStartCallback, this, _1)); 
  haod_server_aserver_.registerStopCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverStopCallback, this)); 
  haod_server_aserver_.registerIsFinishedCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverIsFinishedCallback, this)); 
  haod_server_aserver_.registerHasSucceedCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverHasSucceedCallback, this)); 
  haod_server_aserver_.registerGetResultCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverGetResultCallback, this, _1)); 
  haod_server_aserver_.registerGetFeedbackCallback(boost::bind(&TibiDaboHaodAlgNode::haod_serverGetFeedbackCallback, this, _1)); 
  haod_server_aserver_.start();
  
  // [init action clients]
  this->new_joy_msg=false;
  this->joy_action=none;
  this->language=english;

  this->new_haod_action=false;
  this->haod_need_help=false;
  this->stop_haod=false;
  this->init_x=0;
  this->init_y=0;

  this->hri_action_done=false;
  this->hri_client_goal_.sequence_file.resize(5,std::string(""));
  this->hri_client_goal_.sequence_file[2]="head_home.xml";
  hri_clientMakeActionRequest();
  while(!this->hri_action_done)
    usleep(100000);
  this->hri_client_goal_.sequence_file[2]="";

  this->tracking_head=false;
  this->JointTrajectoryPoint_msg_.positions.resize(2);
  this->JointTrajectoryPoint_msg_.positions[0]=0;
  this->JointTrajectoryPoint_msg_.positions[1]=0;
  this->JointTrajectoryPoint_msg_.velocities.resize(2);
  this->JointTrajectoryPoint_msg_.velocities[0]=2.61;
  this->JointTrajectoryPoint_msg_.velocities[1]=2.61;

  srand(time(NULL));
}

void TibiDaboHaodAlgNode::execute_hri_action(hri_actions action)
{
  int random_answer=0;

  switch(action)
  {
    case hri_intro: if(this->language==catalan)
                      this->hri_client_goal_.sequence_file[0] = catalan_speech[0];
                    else if(this->language==english)
                      this->hri_client_goal_.sequence_file[0]  = english_speech[0];
                    else
                      this->hri_client_goal_.sequence_file[0] = spanish_speech[0];
                    this->hri_client_goal_.sequence_file[1] = "";
                    this->hri_client_goal_.sequence_file[2] = head_motion[0];
                    this->hri_client_goal_.sequence_file[4] = right_arm_motion[0];
                    this->hri_client_goal_.sequence_file[3]  = left_arm_motion[0];
                    hri_clientMakeActionRequest();
                    break;
    case hri_init: if(this->language==catalan)
                     this->hri_client_goal_.sequence_file[0] = catalan_speech[1];
                   else if(this->language==english)
                     this->hri_client_goal_.sequence_file[0]  = english_speech[1];
                   else
                     this->hri_client_goal_.sequence_file[0] = spanish_speech[1];
                   this->hri_client_goal_.sequence_file[1] = "";
                   this->hri_client_goal_.sequence_file[2] = head_motion[1];
                   this->hri_client_goal_.sequence_file[4] = right_arm_motion[1];
                   this->hri_client_goal_.sequence_file[3]  = left_arm_motion[1];
                   hri_clientMakeActionRequest();
                   break;
    case hri_help: // select a random speech
                   random_answer=((double)rand()/(double)RAND_MAX)*4+3;
                   if(this->language==catalan)
                     this->hri_client_goal_.sequence_file[0] = catalan_speech[random_answer];
                   else if(this->language==english)
                     this->hri_client_goal_.sequence_file[0]  = english_speech[random_answer];
                   else
                     this->hri_client_goal_.sequence_file[0] = spanish_speech[random_answer];
                   this->hri_client_goal_.sequence_file[1] = "";
                   this->hri_client_goal_.sequence_file[2] = head_motion[1];
                   this->hri_client_goal_.sequence_file[4] = right_arm_motion[1];
                   this->hri_client_goal_.sequence_file[3]  = left_arm_motion[1];
                   hri_clientMakeActionRequest();
                   break;
    case hri_exit: if(this->language==catalan)
                     this->hri_client_goal_.sequence_file[0] = catalan_speech[2];
                   else if(this->language==english)
                     this->hri_client_goal_.sequence_file[0]  = english_speech[2];
                   else
                     this->hri_client_goal_.sequence_file[0] = spanish_speech[2];
                   this->hri_client_goal_.sequence_file[1] = "";
                   this->hri_client_goal_.sequence_file[2] = head_motion[2];
                   this->hri_client_goal_.sequence_file[4] = right_arm_motion[2];
                   this->hri_client_goal_.sequence_file[3]  = left_arm_motion[2];
                   hri_clientMakeActionRequest();
                   break;
  }
}

TibiDaboHaodAlgNode::~TibiDaboHaodAlgNode(void)
{
  // [free dynamic memory]
}

void TibiDaboHaodAlgNode::mainNodeThread(void)
{
  double pan_angle,tilt_angle;
  static haod_states state=haod_idle;
  static int init_fail_count=0,user_input_timeout=0;

  this->alg_.lock(); 
  switch(state)
  {
    case haod_idle: if(this->new_joy_msg)
                    {
                      if(this->joy_action==help)
                      {
                        state=haod_hri_intro;
                        // initialize the HRI gola message
                        this->execute_hri_action(hri_intro);
                      }
                      else
                        state=haod_idle;
                      this->new_joy_msg=false;
                      this->joy_action=none;
                    }
                    else if(this->new_haod_action)
                    {
                      state=haod_init;
                      this->new_haod_action=false;
                      init_fail_count=0;
                    }
                    else
                      state=haod_idle;
                    ROS_INFO("HAOD State: idle");
                    break;
    case haod_hri_intro: if(this->hri_action_done)
                           state=haod_idle;
                         else if(this->new_joy_msg && this->joy_action==force_end)
                         {
                           this->new_joy_msg=false;
                           this->joy_action=none;
                           hri_client_client_.cancelGoal();
                           haod_server_aserver_.setAborted();
                           if(this->tracking_head)
                             follow_target_client_.cancelGoal();    
                           state=haod_idle;
                         }
                         else
                           state=haod_hri_intro;
                         ROS_INFO("HAOD State: hri_intro");
                         break;
    case haod_init: this->haod_init_srv_.request.x=this->init_x;
                    this->haod_init_srv_.request.y=this->init_y;
                    if (haod_init_client_.call(haod_init_srv_)) 
                    { 
                      if(this->haod_init_srv_.response.success)
                        state=haod_detect;
                      else
                      {
                        init_fail_count++;
                        if(init_fail_count>10)
                        {
                          state=haod_hri_init;
                          // initialize the HRI gola message
                          this->execute_hri_action(hri_init);
                        }
                        else
                          state=haod_init;
                      }
                    } 
                    else 
                    { 
                      ROS_INFO("TibiDaboHaodAlgNode:: Failed to Call Server on topic haod_init "); 
                      state=haod_init;
                    }
                    ROS_INFO("HAOD State: haod_init");

                    break;
    case haod_hri_init: if(this->hri_action_done)
                        {
                          state=haod_idle;
                          haod_server_aserver_.setAborted();
                          init_fail_count=0;
                        }
                        else if(this->new_joy_msg && this->joy_action==force_end)
                        {
                          this->new_joy_msg=false;
                          this->joy_action=none;
                          hri_client_client_.cancelGoal();
                          haod_server_aserver_.setAborted();
                          if(this->tracking_head)
                            follow_target_client_.cancelGoal();
                          state=haod_idle;
                        }
                        else
                          state=haod_hri_init;
                        ROS_INFO("HAOD State: hri_init");
                        break;
    case haod_detect: if(this->new_joy_msg)
                      {
                        if(this->joy_action==end)
                        {
                          state=haod_hri_exit;
                          // initialize the HRI gola message
                          this->execute_hri_action(hri_exit);
                        }
                        else if(this->joy_action==force_end)
                        {
                          haod_server_aserver_.setAborted();
                          if(this->tracking_head)
                            follow_target_client_.cancelGoal();
                          state=haod_idle;
                        }
                        else
                          state=haod_detect;
                        this->new_joy_msg=false;
                        this->joy_action=none;
                      }
                      else if(this->new_haod_action)
                      {
                        state=haod_init;
                        this->new_haod_action=false;
                        init_fail_count=0;
                      }
                      else if(this->stop_haod)
                      {
                        state=haod_idle;
                      }
                      else
                      {
                        if(haod_detect_client_.call(haod_detect_srv_)) 
                        { 
                          if(!this->haod_detect_srv_.response.success)
                          {
                            state=haod_detect;
                            // update the target angles
                            if(this->haod_detect_srv_.response.x>=0 && this->haod_detect_srv_.response.y>=0)
                            {
                              pan_angle = -atan2(this->haod_detect_srv_.response.x-256,833);
                              tilt_angle = -atan2(this->haod_detect_srv_.response.y-192,835);
                              this->JointTrajectoryPoint_msg_.positions[0]=pan_angle;
                              this->JointTrajectoryPoint_msg_.positions[1]=tilt_angle;
                              this->target_joints_publisher_.publish(this->JointTrajectoryPoint_msg_);
                            
                              // start the head tracking (the first time only) 
                              if(!this->tracking_head)
                                follow_targetMakeActionRequest();
                            }
                          }
                          else
                          {
                            state=haod_hri_help;
                            this->haod_need_help=true;
                            this->execute_hri_action(hri_help);
                          }
                        }
                        else 
                        { 
                          ROS_INFO("TibiDaboHaodAlgNode:: Failed to Call Server on topic haod_detect "); 
                           
                        }
                      }
                      ROS_INFO("HAOD State: haod_detect");
                      break;
    case haod_hri_help: if(this->hri_action_done)
                        {
                          state=haod_user_input;
                          user_input_timeout=0;
                        }
                        else if(this->new_joy_msg && this->joy_action==force_end)
                        {
                          this->new_joy_msg=false;
                          this->joy_action=none;
                          hri_client_client_.cancelGoal();
                          haod_server_aserver_.setAborted();
                          if(this->tracking_head)
                            follow_target_client_.cancelGoal();
                          state=haod_idle;
                        }
                        else
                          state=haod_hri_help;
                        ROS_INFO("HAOD State: hri_help");
                        break;
    case haod_user_input: if(this->new_joy_msg)
                          {
                            user_input_timeout=0;
                            if(this->joy_action==valid_det || joy_action==invalid_det)
                            {
                              state=haod_learn;
                              this->haod_need_help=false;
                            }
                            else if(this->joy_action==end)
                            {
                              state=haod_hri_exit;
                              // initialize the HRI gola message
                              this->execute_hri_action(hri_exit);
                              this->joy_action=none;
                              this->haod_need_help=false;
                            }
                            else if(this->joy_action==force_end)
                            {
                              this->joy_action=none;
                              hri_client_client_.cancelGoal();
                              haod_server_aserver_.setAborted();
                              if(this->tracking_head)
                                follow_target_client_.cancelGoal();
                              state=haod_idle;
                            }
                            this->new_joy_msg=false;
                          }
                          else
                          {
                            user_input_timeout++;
                            if(user_input_timeout>100)
                            {
                              state=haod_detect;
                              this->haod_need_help=false;
                            }
                            else
                              state=haod_user_input;
                          }
                          ROS_INFO("HAOD State: haod_user_input");
                          break;
    case haod_learn: if(this->joy_action==valid_det)
                       this->haod_learn_srv_.request.valid=true;
                     else
                       this->haod_learn_srv_.request.valid=false;
                     if (haod_learn_client_.call(haod_learn_srv_)) 
                     { 
                       state=haod_detect;
                     } 
                     else 
                     { 
                       ROS_INFO("TibiDaboHaodAlgNode:: Failed to Call Server on topic haod_learn "); 
                       state=haod_learn;
                     }
                     ROS_INFO("HAOD State: haod_learn");
                     break;
    case haod_hri_exit: if(this->hri_action_done)
                        {
                          state=haod_idle;
                          haod_server_aserver_.setAborted();
                        }
                        else if(this->new_joy_msg && this->joy_action==force_end)
                        {
                          this->new_joy_msg=false;
                          this->joy_action=none;
                          hri_client_client_.cancelGoal();
                          haod_server_aserver_.setAborted();
                          if(this->tracking_head)
                            follow_target_client_.cancelGoal();
                          state=haod_idle;
                        }
                        else
                          state=haod_hri_exit;
                        ROS_INFO("HAOD State: hri_exit");
                        break;
    default:
             break;
  }
  this->alg_.unlock(); 
  // [fill msg structures]
  
  // [fill action structure and make request to the action server]

  // [publish messages]
}

/*  [subscriber callbacks] */
void TibiDaboHaodAlgNode::joy_callback(const sensor_msgs::Joy::ConstPtr& msg) 
{ 
  //ºROS_INFO("TibiDaboHaodAlgNode::joy_callback: New Message Received"); 

  //use appropiate mutex to shared variables if necessary 
  this->alg_.lock(); 
  this->new_joy_msg=true;
  if(msg->buttons[wiimote::State::MSG_BTN_1]==1)// valid detection
    this->joy_action=valid_det;
  else if(msg->buttons[wiimote::State::MSG_BTN_2]==1)// invalid detection
    this->joy_action=invalid_det;
  else if(msg->buttons[wiimote::State::MSG_BTN_B]==1)// invalid detection
    this->joy_action=end;
  else if(msg->buttons[wiimote::State::MSG_BTN_HOME]==1)// invalid detection
    this->joy_action=help;
  else if(msg->buttons[wiimote::State::MSG_BTN_PLUS]!=0)// change language
  {
    if(msg->buttons[wiimote::State::MSG_BTN_PLUS]==1) this->language=catalan;
    else if(msg->buttons[wiimote::State::MSG_BTN_PLUS]==2) this->language=english;
    else if(msg->buttons[wiimote::State::MSG_BTN_PLUS]==3) this->language=spanish; 
  }  
  else if(msg->buttons[wiimote::State::MSG_BTN_MINUS]==1)// change tab
    this->joy_action=force_end;
  else
    this->joy_action=none;
  //this->joy_mutex_.enter(); 

  //unlock previously blocked shared variables 
  this->alg_.unlock(); 
  //this->joy_mutex_.exit(); 
}

/*  [service callbacks] */

/*  [action callbacks] */
void TibiDaboHaodAlgNode::follow_targetDone(const actionlib::SimpleClientGoalState& state,  const iri_nav_msgs::followTargetResultConstPtr& result) 
{ 
  if( state.toString().compare("SUCCEEDED") == 0 ) 
    ROS_INFO("TibiDaboHaodAlgNode::follow_targetDone: Goal Achieved!"); 
  else 
    ROS_INFO("TibiDaboHaodAlgNode::follow_targetDone: %s", state.toString().c_str()); 
  this->tracking_head=false;

  //copy & work with requested result 
} 

void TibiDaboHaodAlgNode::follow_targetActive() 
{ 
  //ROS_INFO("TibiDaboHaodAlgNode::follow_targetActive: Goal just went active!"); 
} 

void TibiDaboHaodAlgNode::follow_targetFeedback(const iri_nav_msgs::followTargetFeedbackConstPtr& feedback) 
{ 
  //ROS_INFO("TibiDaboHaodAlgNode::follow_targetFeedback: Got Feedback!"); 

  bool feedback_is_ok = true; 

  //analyze feedback 
  //my_var = feedback->var; 

  //if feedback is not what expected, cancel requested goal 
  if( !feedback_is_ok ) 
  { 
    follow_target_client_.cancelGoal(); 
    //ROS_INFO("TibiDaboHaodAlgNode::follow_targetFeedback: Cancelling Action!"); 
  } 
}
void TibiDaboHaodAlgNode::haod_serverStartCallback(const tibi_dabo_msgs::haodGoalConstPtr& goal)
{ 
  alg_.lock(); 
    //check goal 
  this->new_haod_action=true;
  this->init_x=goal->x;
  this->init_y=goal->y;
    //execute goal 
  alg_.unlock(); 
} 

void TibiDaboHaodAlgNode::haod_serverStopCallback(void) 
{ 
  alg_.lock(); 
  this->stop_haod=true;
  this->haod_need_help=false;
    //stop action 
  alg_.unlock(); 
} 

bool TibiDaboHaodAlgNode::haod_serverIsFinishedCallback(void) 
{ 
  bool ret = false; 

  alg_.lock(); 
    //if action has finish for any reason 
    //ret = true; 
  alg_.unlock(); 

  return ret; 
} 

bool TibiDaboHaodAlgNode::haod_serverHasSucceedCallback(void) 
{ 
  bool ret = false; 

  alg_.lock(); 
    //if goal was accomplished 
    //ret = true; 
  alg_.unlock(); 

  return ret; 
} 

void TibiDaboHaodAlgNode::haod_serverGetResultCallback(tibi_dabo_msgs::haodResultPtr& result) 
{ 
  alg_.lock(); 
    //update result data to be sent to client 
    //result->data = data; 
  alg_.unlock(); 
} 

void TibiDaboHaodAlgNode::haod_serverGetFeedbackCallback(tibi_dabo_msgs::haodFeedbackPtr& feedback) 
{ 
  alg_.lock(); 
    //keep track of feedback 
    //ROS_INFO("feedback: %si", feedback->data.c_str()); 
  if(this->haod_need_help)
    feedback->assistance=true;
  else
    feedback->assistance=false;
  alg_.unlock(); 
}
void TibiDaboHaodAlgNode::hri_clientDone(const actionlib::SimpleClientGoalState& state,  const tibi_dabo_msgs::sequenceResultConstPtr& result) 
{ 
  if( state.toString().compare("SUCCEEDED") == 0 ) 
    ROS_INFO("TibiDaboHaodAlgNode::hri_clientDone: Goal Achieved!"); 
  else 
    ROS_INFO("TibiDaboHaodAlgNode::hri_clientDone: %s", state.toString().c_str()); 
  this->hri_action_done=true;

  //copy & work with requested result 
} 

void TibiDaboHaodAlgNode::hri_clientActive() 
{ 
  //ROS_INFO("TibiDaboHaodAlgNode::hri_clientActive: Goal just went active!"); 
} 

void TibiDaboHaodAlgNode::hri_clientFeedback(const tibi_dabo_msgs::sequenceFeedbackConstPtr& feedback) 
{ 
  //ROS_INFO("TibiDaboHaodAlgNode::hri_clientFeedback: Got Feedback!"); 

  bool feedback_is_ok = true; 

  //analyze feedback 
  //my_var = feedback->var; 

  //if feedback is not what expected, cancel requested goal 
  if( !feedback_is_ok ) 
  { 
    hri_client_client_.cancelGoal(); 
    //ROS_INFO("TibiDaboHaodAlgNode::hri_clientFeedback: Cancelling Action!"); 
  } 
}

/*  [action requests] */
void TibiDaboHaodAlgNode::follow_targetMakeActionRequest() 
{ 
  ROS_INFO("TibiDaboHaodAlgNode::follow_targetMakeActionRequest: Starting New Request!"); 

  //wait for the action server to start 
  //will wait for infinite time 
  follow_target_client_.waitForServer();  
  ROS_INFO("TibiDaboHaodAlgNode::follow_targetMakeActionRequest: Server is Available!"); 

  //send a goal to the action 
  //follow_target_goal_.data = my_desired_goal; 
  follow_target_client_.sendGoal(follow_target_goal_, 
              boost::bind(&TibiDaboHaodAlgNode::follow_targetDone,     this, _1, _2), 
              boost::bind(&TibiDaboHaodAlgNode::follow_targetActive,   this), 
              boost::bind(&TibiDaboHaodAlgNode::follow_targetFeedback, this, _1)); 
  ROS_INFO("TibiDaboHaodAlgNode::follow_targetMakeActionRequest: Goal Sent. Wait for Result!"); 
  this->tracking_head=true;
}
void TibiDaboHaodAlgNode::hri_clientMakeActionRequest() 
{ 
  ROS_INFO("TibiDaboHaodAlgNode::hri_clientMakeActionRequest: Starting New Request!"); 

  //wait for the action server to start 
  //will wait for infinite time 
  hri_client_client_.waitForServer();  
  ROS_INFO("TibiDaboHaodAlgNode::hri_clientMakeActionRequest: Server is Available!"); 

  //send a goal to the action 
  //hri_client_goal_.data = my_desired_goal; 
  hri_client_client_.sendGoal(hri_client_goal_, 
              boost::bind(&TibiDaboHaodAlgNode::hri_clientDone,     this, _1, _2), 
              boost::bind(&TibiDaboHaodAlgNode::hri_clientActive,   this), 
              boost::bind(&TibiDaboHaodAlgNode::hri_clientFeedback, this, _1)); 
  ROS_INFO("TibiDaboHaodAlgNode::hri_clientMakeActionRequest: Goal Sent. Wait for Result!"); 
  this->hri_action_done=false;
}

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

  this->alg_.unlock();
}

void TibiDaboHaodAlgNode::addNodeDiagnostics(void)
{
}

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