// ============================================================================
// Process the message queue of the Task
// ============================================================================    
void AcquisitionTask::process_message(yat::Message& msg) throw (Tango::DevFailed) 
{
    try
    {
        switch ( msg.type() )
        {
            //-----------------------------------------------------------------------------------------------
            case yat::TASK_INIT:
            {
                INFO_STREAM << "-> yat::TASK_INIT" << endl;

                try
                {
                    m_acq_conf = msg.get_data<AcqConfig>();                    
                    set_state(Tango::STANDBY);    
                    set_status(string("Waiting for request ..."));
                }
                catch( Tango::DevFailed& df )
                {
                    ERROR_STREAM << df <<endl;
                    set_state(Tango::FAULT);
                    set_status(string(df.errors[0].desc));    
                    throw;
                }
            }
            break;
                
            //-----------------------------------------------------------------------------------------------
            case yat::TASK_EXIT:
            {
                INFO_STREAM << "-> yat::TASK_EXIT" << endl;
                try
                {
                    set_state(Tango::INIT);    
                    set_status(string("Acquisition is Stopped."));    
                }
                catch( Tango::DevFailed& df )
                {
                    ERROR_STREAM << df <<endl;
                    set_state(Tango::FAULT);    
                    set_status(string(df.errors[0].desc));
                }                
            }
            break;

            //-----------------------------------------------------------------------------------------------            
            case DEVICE_SNAP_MSG:
            {
                INFO_STREAM << "-> yat::DEVICE_SNAP_MSG" << endl;
                try
                {                
                    set_state(Tango::RUNNING);    
                    set_status(string("Acquisition is Running in snap mode..."));                    
                    m_acq_conf.ct->prepareAcq();
                    m_acq_conf.ct->startAcq();
                }
                catch(Tango::DevFailed &df)
                {
                    ERROR_STREAM << df << endl;
                    on_abort(df);                            
                }
                catch(Exception& e)
                {
                    ERROR_STREAM << e.getErrMsg() << endl;
                    on_abort(e.getErrMsg());                            
                }                    
            }
            break;
        
            //-----------------------------------------------------------------------------------------------            
            case DEVICE_START_MSG:
            {
                INFO_STREAM << "-> yat::DEVICE_START_MSG" << endl;
                try
                {                
                    set_state(Tango::RUNNING);    
                    set_status(string("Acquisition is Running in video mode ..."));
                    m_acq_conf.ct->video()->startLive();
                }
                catch(Tango::DevFailed &df)
                {
                    ERROR_STREAM << df << endl;
                    on_abort(df);                            
                }
                catch(Exception& e)
                {
                    ERROR_STREAM << e.getErrMsg() << endl;
                    on_abort(e.getErrMsg());                            
                }                    
            }
            break;
        
            //----------------------------------------------------------------------------------------------- 
            case DEVICE_STOP_MSG:
            {
                INFO_STREAM << "-> yat::DEVICE_STOP_MSG" << endl;
                try
                {
                    m_acq_conf.ct->stopAcq();
                    m_acq_conf.ct->resetStatus(false);
                    set_state(Tango::STANDBY);
                    set_status(string("Waiting for request ..."));                
                    INFO_STREAM << "Acquisition is Stopped." << endl;
                }
                catch(Tango::DevFailed &df)
                {
                    ERROR_STREAM << df << endl;
                    on_abort(df);                            
                }
                catch(Exception& e)
                {
                    ERROR_STREAM << e.getErrMsg() << endl;
                    on_abort(e.getErrMsg());                            
                }                    
            }
            break;
        
            //----------------------------------------------------------------------------------------------- 
            case DEVICE_ABORT_MSG:
            {
                INFO_STREAM << "-> yat::DEVICE_ABORT_MSG" << endl;
                //display here the final status, otherwise is overwrited.
                set_state(Tango::FAULT);
                set_status(m_acq_conf.abort_status_message);
                INFO_STREAM << "Acquisition is Aborted." << endl;    
            }
            break;
        
            //-----------------------------------------------------------------------------------------------
        }
    }
    catch( yat::Exception& ex )
    {
        //- TODO Error Handling
        INFO_STREAM<<ex.errors[0].desc<<endl;
        throw;
    }
}
// ============================================================================
// UnsolicitedMsgReader::handle_message
// ============================================================================
void UnsolicitedMsgReader::handle_message (yat::Message& _msg)
	throw (yat::Exception)
{
  YAT_TRACE("galil::UnsolicitedMsgReader::handle_message"); 

  //- The Task's lock_ is locked
	//-------------------------------------------------------------------

	//- YAT_LOG("UnsolicitedMsgReader::handle_message::receiving msg " << _msg.to_string());

	//- handle msg
  switch (_msg.type())
	{

	  //- THREAD_INIT ----------------------
	  case yat::TASK_INIT:
	    {
  	    //- "initialization" code goes here
  	    YAT_LOG("UnsolicitedMsgReader::handle_message::THREAD_INIT::thread is starting up");
      } 
		  break;

		//- THREAD_EXIT ----------------------
		case yat::TASK_EXIT:
		  {
  			//- "release" code goes here
  			YAT_LOG("UnsolicitedMsgReader::handle_message::THREAD_EXIT::thread is quitting");
      }
			break;

		//- THREAD_PERIODIC ------------------
		case yat::TASK_PERIODIC:
		  {
		    //- enter critical section
		    yat::AutoMutex<yat::Mutex> guard(this->Task::m_lock);
		    
		    //- get unsolicited msg
		    try
		    {
  		    //- code relative to the task's periodic job goes here
  		    //- YAT_LOG("UnsolicitedMsgReader::handle_message::handling THREAD_PERIODIC msg");
          std::string unsolicited_msg;
          this->hw_io()->out(unsolicited_msg);
          if (unsolicited_msg.size())
          {
            YAT_LOG("***************************************************************************");
            YAT_LOG("* UnsolicitedMsgReader::got the following unsolicited msg from controller *");
            YAT_LOG("***************************************************************************");
            YAT_LOG("unsolicited msg length..." << unsolicited_msg.size());
            YAT_LOG("unsolicited msg.........." << unsolicited_msg);
            YAT_LOG("***************************************************************************");
          }
        }
        catch (Tango::DevFailed& te)
	      {
	        YAT_LOG("UnsolicitedMsgReader::handle_message::TANGO exception caught");
	        _TANGO_TO_YAT_EXCEPTION(te, ye);
	        throw ye;  
	      }
	      catch (...)
	      {		
	        YAT_LOG("UnsolicitedMsgReader::handle_message::UNKNOWN exception caught");
	        throw;  
	      }
      }
		  break;

  	default:
  		//- YAT_LOG("UnsolicitedMsgReader::handle_message::unhandled msg type received");
  		break;
	}

	//- YAT_LOG("UnsolicitedMsgReader::handle_message::message_handler:msg " << _msg.to_string() << " successfully handled");
}
void Camera::handle_message(yat::Message& msg) throw ( yat::Exception)
{
    DEB_MEMBER_FUNCT();
    try
    {
        switch (msg.type())
        {

                //-----------------------------------------------------
            case yat::TASK_INIT:
            {
                DEB_TRACE() << "Camera::->TASK_INIT";
                //NOP
            }
                break;

                //-----------------------------------------------------
            case yat::TASK_EXIT:
            {
                DEB_TRACE() << "Camera::->TASK_EXIT";
                try
                {
                    //- abort acquisition
                    DEB_TRACE() << "Send command abort";
                    _sendCmdAndReceiveAnswer("abort");

                    //-  Delete device allocated objects
                    DEB_TRACE() << "Disconnect from MARCCD socket server";
                    m_sock.disconnect();

                    //- yat internal cooking
                    DEB_TRACE() << "Terminate yat::socket";
                    yat::Socket::terminate();
                }
                catch (yat::SocketException & ySe)
                {
                    std::stringstream ssError;
                    for (unsigned i = 0; i < ySe.errors.size(); i++)
                    {
                        ssError << ySe.errors[i].desc << std::endl;
                    }

                    THROW_HW_ERROR(Error) << ssError.str();
                }
                catch (...)
                {
                    THROW_HW_ERROR(Error) << "Camera::TASK_EXIT : Unknown Exception";
                }
            }
                break;

                //-----------------------------------------------------
            case yat::TASK_TIMEOUT:
            {
                DEB_TRACE() << "Camera::->TASK_TIMEOUT";
                //NOP
            }
                break;

                //------------------------------------------------------
            case yat::TASK_PERIODIC:
            {
                DEB_TRACE() << "Camera::->TASK_PERIODIC";
                //NOP
            }
                break;

                //------------------------------------------------------
            case START_MSG:
            {
                DEB_TRACE() << "Camera::->START_MSG";

                try
                {
                    DEB_TRACE() << "Perform acquisition sequence ...";
                    _performAcquisitionSequence();
                }
                catch (yat::SocketException & ySe)
                {
                    m_nb_frames = 0; // This will stop the reader                    
                    std::stringstream ssError;
                    for (unsigned i = 0; i < ySe.errors.size(); i++)
                    {
                        ssError << ySe.errors[i].desc << std::endl;
                    }

                    THROW_HW_ERROR(Error) << ssError.str();
                }
                catch (...)
                {
                    THROW_HW_ERROR(Error) << "Camera::START_MSG : Unknown Exception";
                }
            }
                break;

                //-----------------------------------------------------
            case STOP_MSG:
            {
                DEB_TRACE() << "Camera::->STOP_MSG";

                try
                {
                    DEB_TRACE() << "Perform stop sequence ...";
                    _performStopSequence();
                }
                catch (yat::SocketException & ySe)
                {
                    m_nb_frames = 0; // This will stop the reader                    
                    std::stringstream ssError;
                    for (unsigned i = 0; i < ySe.errors.size(); i++)
                    {
                        ssError << ySe.errors[i].desc << std::endl;
                    }

                    THROW_HW_ERROR(Error) << ssError.str();
                }
                catch (...)
                {
                    THROW_HW_ERROR(Error) << "Camera::STOP_MSG : Unknown Exception";
                }
            }
                break;

                //-----------------------------------------------------
            case BACKGROUND_FRAME_MSG:
            {
                DEB_TRACE() << "Camera::->BACKGROUND_FRAME_MSG";

                try
                {
                    DEB_TRACE() << "Perform background frame ...";
                    _performBackgroundFrame();
                }
                catch (yat::SocketException & ySe)
                {
                    m_nb_frames = 0; // This will stop the reader                    
                    std::stringstream ssError;
                    for (unsigned i = 0; i < ySe.errors.size(); i++)
                    {
                        ssError << ySe.errors[i].desc << std::endl;
                    }

                    THROW_HW_ERROR(Error) << ssError.str();
                }
                catch (...)
                {
                    THROW_HW_ERROR(Error) << "Camera::BACKGROUND_FRAME_MSG : Unknown Exception";
                }
            }
                break;
        }
    }
    catch (yat::Exception& ex)
    {
        DEB_ERROR() << "Camera::handle_message : " << ex.errors[0].desc;
        THROW_HW_ERROR(Error) << "Camera::handle_message : " << ex.errors[0].desc;
    }
    catch (...)
    {
        DEB_ERROR() << "Camera::handle_message : " << "YAT Task Unknown error ! ";
        THROW_HW_ERROR(Error) << "Camera::handle_message : " << "YAT Task Unknown error ! ";
    }
}
Exemplo n.º 4
0
// ============================================================================
// Consumer::handle_message
// ============================================================================
void Consumer::handle_message (yat::Message& _msg)
{
	//- YAT_TRACE("Consumer::handle_message");

	//- handle msg
  switch (_msg.type())
	{
	  //- TASK_INIT ----------------------
	  case yat::TASK_INIT:
	    {
  	    //- "initialization" code goes here
  	    YAT_LOG("Consumer::handle_message::TASK_INIT::task is starting up");
        this->ctrl_msg_counter++;
      } 
		  break;
		//- TASK_EXIT ----------------------
		case yat::TASK_EXIT:
		  {
  			//- "release" code goes here
  			YAT_LOG("Consumer::handle_message::TASK_EXIT::task is quitting");
        this->ctrl_msg_counter++;
      }
			break;
		//- TASK_PERIODIC ------------------
		case yat::TASK_PERIODIC:
		  {
  		  //- code relative to the task's periodic job goes here
  		  YAT_LOG("Consumer::handle_message::handling TASK_PERIODIC msg");
      }
		  break;
		//- TASK_TIMEOUT -------------------
		case yat::TASK_TIMEOUT:
		  {
  		  //- code relative to the task's tmo handling goes here
  		  YAT_LOG("Consumer::handle_message::handling TASK_TIMEOUT msg");
      }
		  break;
		//- USER_DEFINED_MSG -----------------
		case kDUMMY_MSG:
		  {
  		  //- YAT_LOG("Consumer::handle_message::handling kDUMMY_MSG user msg");
        this->user_msg_counter++;
#if defined (YAT_DEBUG)
        if (_msg.id() < last_msg_id)
          this->wrong_order_msg_counter++;
        else
          this->lost_msg_counter += _msg.id() - (this->last_msg_id + 1);
#endif
        //- simulate some time consuming activity
        yat::ThreadingUtilities::sleep(0, 10000);
  		}
  		break;
    //- kDATA_MSG -------------------
    case kDATA_MSG:
      {
        //- code relative to the task's tmo handling goes here
        SharedBuffer* sb = _msg.detach_data<SharedBuffer>();
        YAT_LOG("got a SharedBuffer containing " << sb->length() << " elements");
        sb->release();
      }
      break;
  	default:
  		YAT_LOG("Consumer::handle_message::unhandled msg type received");
  		break;
	}
#if defined (YAT_DEBUG)
  this->last_msg_id = _msg.id();
#endif
}