// ============================================================================ // 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 ! "; } }
// ============================================================================ // 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 }