Пример #1
0
  void
  FrameStoreInit::addXmlFrames(Miro::ConfigDocument& xmlConfig)
  {
    // get all frames defined in the config file
    xmlConfig.setSection("Frames");
    typedef Miro::ConfigDocument::StringVector StringVector;
    StringVector frames = xmlConfig.getInstances("rapid::FrameRpyParameters");

    // add all frames specified in RPY
    StringVector::iterator first, last = frames.end();
    for (first = frames.begin(); first != last; ++first) {
      FrameRpyParameters frame;
      xmlConfig.getType("rapid::FrameRpyParameters", *first, frame);
      keyFrameSubstitute(frame.parent); 
      addRpyFrame(keyFrameSubstitute(*first), frame);
    }

    // add all frames specified in Quaternios
    frames = xmlConfig.getInstances("rapid::FrameQParameters");
    last = frames.end();
    for (first = frames.begin(); first != last; ++first) {
      FrameQParameters frame;
      xmlConfig.getType("rapid::FrameQParameters", *first, frame);
      keyFrameSubstitute(frame.parent); 
      addQFrame(keyFrameSubstitute(*first), frame);
    }
  }
int
main(int argc, char *argv[])
{
  int rc = 0;

  // Parameters to be passed to the services
  Base::Parameters parameters;

  try {
    // Config file processing
    Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
    config->setRobotType("B21");
    config->getParameters("base", parameters);
    delete config;

#ifdef DEBUG
    cout << "  base parameters:" << endl << parameters << endl;
#endif

    DBG(cout << "Initialize mcp connection." << endl);
    McpPerformance mcpPerformance(argc, argv, parameters);

    int messages = 300;
    
    if (argc >=2)
      messages = atoi(argv[1]);

    cout << "Stressing Mcp by sending " << messages << " commands:" << endl;

    ACE_Time_Value start = ACE_OS::gettimeofday();
    cout << "Start time: " << start << endl;

    for (int i = messages / 2; i < 0; --i) {
      mcpPerformance.b21Motion.setRotateVelocity(M_PI/6);
      mcpPerformance.b21Motion.setRotateVelocity(M_PI/12);
    }
    ACE_Time_Value stop = ACE_OS::gettimeofday();

    cout << "Ending performance test." << endl;
    cout << "End time: " << stop << endl;
    cout << "Elapsed time: " << stop - start << endl;
    double msec = (stop-start).msec();
    cout << "Processing time per Messages: " 
	 << (msec / 1000. / messages) << endl;
  }
  catch (const Miro::CException& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }
  catch (const Miro::Exception& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }
  catch (...) {
    cerr << "Uncaught exception: " << endl;
    rc = 1;
  }
  return rc;
}
int
main(int argc, char *argv[])
{

  Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
  Laser::Parameters * parameters = Laser::Parameters::instance();

  // Config file processing
  Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
  config->setSection("Robot");
  config->getParameters("Robot", *robotParameters);
  config->setSection("Sick");
  config->getParameters("Laser", *parameters);
  delete config;

  log(Miro::INFO, "Initialize server daemon.");
  Miro::LaserServer laserServer(argc, argv);

#ifdef DEBUG
  cout << "  robot parameters:" << endl << *robotParameters << endl;
  cout << "  parameters:" << endl << *parameters << endl;
#endif

  try {
    log(Miro::INFO, "Ready for service.");
    laserServer.run(8);
    log(Miro::INFO, "Service loop ended, exiting.");
  }
  catch (const Miro::CException& e) {
    log(Miro::FATAL_ERROR, "Miro exception: ");
    cerr << e << endl;
    return 1;
  }
  catch (const CORBA::Exception & e) {
    log(Miro::FATAL_ERROR, "Uncaught CORBA exception: ");
    cerr << e << endl;
    return 1;
  }
  catch (const Miro::Exception& e) {
    log(Miro::FATAL_ERROR, "Miro exception: ");
    cerr << e << endl;
    return 1;
  }
  catch (...) {
    log(Miro::FATAL_ERROR, "Uncaught exception.");
    return 1;
  }
  return 0;
}
Пример #4
0
/**
 * parse command line arguments
 */
int parseArgs(int& argc, char* argv[])
{
  int rc = 0;
  int c;

  // initialize parameters with global instance
  FileReceiverParameters* params = FileReceiverParameters::instance();

  // initialize parameters from config file
  Miro::ConfigDocument* config = Miro::Configuration::document();
  config->setSection("Rapid");
  config->getParameters("kn::FileReceiverParameters", *params);

  // initialize parameters from command line
  ACE_Get_Opt get_opts(argc, argv, "D:S:v?");

  while ((c = get_opts()) != -1) {
    switch (c) {
      case 'D':
        params->dataDestinationDir = get_opts.optarg;
        break;
      case 'S':
        params->dataStagingDir = get_opts.optarg;
        break;
      case 'v':
        verbose = true;
        break;
      case '?':
      default:
        cerr << "usage: " << argv[0] << "[-v?]" << endl
             << "  -D <path> Destination root directory (default: " << params->dataDestinationDir << ")" << endl
             << "  -S <path> Staging directory (default: " << params->dataStagingDir << ")" << endl
             << "  -v verbose mode" << endl
             << "  -? help: emit this text and stop" << endl;
        rc = 1;
    }
  }

  if (verbose) {
    cerr << "RAFT FileReceiver parameters:" << endl;
    cerr << *params << endl;
  }
  return rc;
}
Пример #5
0
  int
  FrameStoreUpdaterSvc::parseArgs(int& argc, char * argv[])
  {
    int rc = 0;
    int c;

    m_verbose = 0;
    
    // initialize parameters from command line
    ACE_Get_Opt get_opts (argc, argv, "v?");
  
    while ((c = get_opts()) != -1) {
      switch (c) {
      case 'v':
        ++m_verbose;
	break;
      case '?':
      default:
        ACE_OS::last_error(EINVAL);
        rc = -1;
      }
    }

    // debug output
    if (rc != 0) {
      cerr << "usage: " << argv[0] << " [-n name] [-v?]\n"
           << "  -v verbose mode\n"
           << "  -? help: print this text and stop" << endl;
    }
    
    // initialize parameters with global instance
    m_params =  FrameStoreUpdaterSvcParameters::instance();
    // initialize parameters from config file
    Miro::ConfigDocument * config = Miro::Configuration::document();
    config->setSection("FrameStore");
    config->getParameters("kn::FrameStoreUpdaterSvcParameters", *m_params);
    
    if (m_verbose) {
      cerr << "FrameStoreUpdater Parameters: " << endl
	   << *m_params << endl;
    }

    return rc;
  }
Пример #6
0
  int
  SystemInfoSvc::parseArgs(int& argc, char* argv[])
  {
    int rc = 0;
    int c;

    // initialize parameters with global instance
    m_params = SystemInfoSvcParameters::instance();
    // reset defaults
    SystemInfoSvcParameters default_params;
    *m_params = default_params;

    // initialize parameters from config file
    Miro::ConfigDocument * config = Miro::Configuration::document();
    config->setSection("Rapid");
    config->getParameters("kn::SystemInfoSvcParameters", *m_params);

    // initialize parameters from command line
    ACE_Get_Opt get_opts (argc, argv, "r:v?");
  
    while ((c = get_opts()) != -1) {
      switch (c) {
        case 'r':
          m_params->refreshInterval.set(atof(get_opts.optarg));
        case 'v':
	        ++m_verbose;
	        break;
        case '?':
        default:
          cerr << "usage: " << argv[0] << "[-r interval] [-vV?]" << endl
              << "  -r [interval] how often to refresh info (default: 1s)" << endl
              << "  -v verbose mode" << endl
              << "  -? help: emit this text and stop" << endl;
          rc = 1;
      }
    }
    
    if (m_verbose) {
      cerr << "SystemInfoSvc parameters:" << endl
           << *m_params << endl;
    }
    return rc;
  }
int
main(int argc, char *argv[])
{
  int rc = 0;
  try {
    Miro::Log::init(argc, argv);
    Miro::Configuration::init(argc, argv);

    // Init TAO Factories
    TAO_Notify_Default_CO_Factory::init_svc();
    TAO_Notify_Default_POA_Factory::init_svc();
    TAO_Notify_Default_Collection_Factory::init_svc();
    TAO_Notify_Default_EMO_Factory::init_svc();

    // Parameters to be passed to the services
    Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
    Base::Parameters * baseParameters = Base::Parameters::instance();
    Msp::Parameters * mspParameters = Msp::Parameters::instance();
    
    // Config file processing
    Miro::ConfigDocument * config = Miro::Configuration::document();
    config->setSection("Robot");
    config->getParameters("Miro::RobotParameters", *robotParameters);
    config->setSection("B21");
    config->getParameters("B21::Parameters", *baseParameters);
    config->getParameters("Msp::Parameters", *mspParameters);

    MIRO_LOG_OSTR(LL_NOTICE , "  robot parameters:\n" << robotParameters);
    MIRO_LOG_OSTR(LL_NOTICE , "  base parameters:\n" << baseParameters);
    MIRO_LOG_OSTR(LL_NOTICE , "  msp parameters:\n" << mspParameters);
    
    MIRO_LOG(LL_NOTICE,"Initialize server daemon.");
    B21Base b21Base(argc, argv);
    try {
      MIRO_LOG(LL_NOTICE , "Loop forever handling events." );
      b21Base.run(8);
      MIRO_LOG(LL_NOTICE , "b21Base ended, exiting." );
    }
    catch (const Miro::EOutOfBounds& e) {
      MIRO_LOG(LL_ERROR , "OutOfBounds exception: Wrong parameter for device initialization." );
      rc = 1;
    }
    catch (const Miro::EDevIO& e) {
      MIRO_LOG(LL_ERROR , "DevIO exception: Device access failed." );
      rc = 1;
    }
    catch (const CORBA::Exception & e) {
      MIRO_LOG_OSTR(LL_ERROR , "Uncaught CORBA exception: " << e );
      rc = 1;
    }
  }
  catch (const Miro::Exception& e) {
    MIRO_LOG_OSTR(LL_ERROR , "Miro exception: " << e );
    rc = 1;
  }
  return rc;
}
int
main(int argc, char *argv[])
{
  int rc = 0;

  // command line paramter parsing
  // -> increase log level for verbosity (-MLL 7)
  Miro::Log::init(argc, argv);
  // -> specify the config file (-MCF Config.xml)
  Miro::Configuration::init(argc, argv);
  // Get global configuration document
  Miro::ConfigDocument * config = Miro::Configuration::document();

  // Read parameters from document...
  try {
    // global parameters
    // -> those are accessed through singletons
    Test::MyParameters * params = Test::MyParameters::instance();
    Test::MoreParameters * more_params = Test::MoreParameters::instance();

    // individual parameters
    // -> those are locally allocated
    Test::FriendsParameters tom;
    Test::FriendsParameters cherry;

    // selecting the paramter section
    config->setSection("My_test_section");

    // reading global parameters (if present)
    // -> no name required
    config->getParameters("Test::MyParameters", *params);
    config->getParameters("Test::MoreParameters", *more_params);

    // reading individual parameter settings (if present)
    // -> referred by name
    config->getType("Test::FriendsParameters", "Tom", tom);
    config->getType("Test::FriendsParameters", "Cherry", cherry);

    // debug output 
    cout << "  my paramters:" << endl << *params << endl << endl;
    cout << "  more paramters:" << endl << *more_params << endl << endl;
    cout << "  tom's paramters:" << endl << tom << endl << endl;
    cout << "  cherry's paramters:" << endl << cherry << endl << endl;

  }
  catch (const Miro::CException& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }
  catch (const Miro::Exception& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }

  return rc;
}
int main(int argc, char * argv[])
{
  // Parameters to be passed to the services
  Sparrow::Parameters * parameters = Sparrow::Parameters::instance();

  // Config file processing
  Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
  config->setSection("Sparrow99");
  config->getParameters("sparrowBoard", *parameters);
  delete config;

#ifdef DEBUG
    cout << "  sparrow paramters:" << endl << *parameters << endl;
#endif

  // Initialize server daemon.
  Service service;

  cout << "initialized" << endl;

  Miro::PositionIDL startPos, current;

  service.reactorTask.open(NULL);

  int ticks = 0;
  int niterations = 10;

  if (argc > 1)
    niterations = ACE_OS::atoi(argv[1]);

  cout << "start test" << endl;
  try {
    ACE_Sample_History history (niterations);
    
    ACE_hrtime_t test_start = ACE_OS::gethrtime ();
    for (int i = 0; i < niterations; ++i) {

      service.connection.setPower(0, 0);
      
      ACE_OS::sleep(ACE_Time_Value(1, (int)floor(rand1() * 100000.)));
      startPos = service.odometryImpl->getPosition();
      cout << "start position:" << startPos << endl;

      ACE_hrtime_t start = ACE_OS::gethrtime ();

      service.connection.setPower(10000, 10000);
      do {
	current = service.odometryImpl->getWaitPosition();
	++ticks;
      }
      while (startPos.point.x == current.point.x &&
	     startPos.point.y == current.point.y &&
	     startPos.heading == current.heading);
      
      ACE_hrtime_t now = ACE_OS::gethrtime ();
      history.sample (now - start);
    }
    service.connection.setPower(0, 0);

    ACE_hrtime_t test_end = ACE_OS::gethrtime ();

    ACE_DEBUG ((LM_DEBUG, "test finished\n"));
    
    ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
    ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
    ACE_DEBUG ((LM_DEBUG, "done\n"));

    history.dump_samples ("HISTORY", gsf);

    ACE_Basic_Stats stats;
    history.collect_basic_stats (stats);
    stats.dump_results ("Total", gsf);
    
    ACE_Throughput_Stats::dump_throughput ("Total", gsf,
					   test_end - test_start,
					   stats.samples_count ());

    // data evaluation
    cout << "ticks: " << ticks << endl;
    cout << "end position: " << current << endl;
  }
  catch (const Miro::Exception & e) {
    cerr << "Miro exception thrown:" << e << endl;
    return 1;
  }

  service.reactorTask.cancel();
  return 0;
}
int main(int argc, char * argv[])
{
  // Parameters to be passed to the services
  Sparrow::Parameters * parameters = Sparrow::Parameters::instance();

  // Config file processing
  Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
  config->setSection("Sparrow99");
  config->getParameters("sparrowBoard", *parameters);
  delete config;

#ifdef DEBUG
    cout << "  sparrow paramters:" << endl << *parameters << endl;
#endif

  // Initialize server daemon.
  Service service;

  cout << "initialized" << endl;

  int time;

  service.reactorTask.open(NULL);

  ACE_OS::sleep(ACE_Time_Value(2));

  if (argc > 1)
    time = atoi(argv[1]);
  else {
    cerr << "usage: kickerTest <kick msec>" << endl;
    return 1;
  }
  
  try {
    int digital = 1;

    while (true) {
      Miro::Guard guard(service.pSparrowConsumer->digitalMutex);
      service.pSparrowConsumer->digitalCond.wait();

      cout << "button" << endl;

      if ((service.pSparrowConsumer->digital[1] & 0x01) && digital == 0) {

	cout << "time (msec): " << time << endl;
	service.connection.kick(time);
      }
      digital = service.pSparrowConsumer->digital[1] & (0x01);

    }
  }
  catch (const Miro::Exception & e) {
    cerr << "Miro exception thrown:" << e << endl;
    return 1;
  }
  catch (...) {
    cerr << "Uncaught exception: " << endl;
    return 1;
  }

  service.reactorTask.cancel();
  return 0;
}
int
main(int argc, char *argv[])
{
  int rc = 0;

  Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
  Laser::Parameters * parameters = Laser::Parameters::instance();

  try {
    Miro::Log::init(argc, argv);
    // Config file processing
    Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
    config->setSection("Robot");
    config->getParameters("Miro::RobotParameters", *robotParameters);
    config->setSection("Sick");
    config->getParameters("Laser::Parameters", *parameters);
    delete config;
    calculateLaserDescription(parameters);

    MIRO_LOG_OSTR(LL_NOTICE, 
		  "Configuration:\n" << 
		  "  robot parameters:" << std::endl <<
		  *robotParameters << std::endl <<
		  "  parameters:" << std::endl <<
		  *parameters);

    MIRO_LOG(LL_NOTICE, "Initialize server daemon.\n");
    Miro::LaserServer laserServer(argc, argv);
    
    try {
      MIRO_LOG(LL_NOTICE, "Loop forever handling events.\n");
      laserServer.run(8);
      MIRO_LOG(LL_NOTICE, "Server loop ended, exiting.\n");
    }
    catch (const Miro::EOutOfBounds& e) {
      MIRO_LOG_OSTR(LL_CRITICAL, 
		    "OutOfBounds exception: Wrong parameter for device initialization."
		    << e);
      rc = 1;
    }
    catch (const Miro::EDevIO& e) {
      MIRO_LOG_OSTR(LL_CRITICAL,
		    "DevIO exception: Device access failed." 
		    << e);
      rc = 1;
    }
    catch (const CORBA::Exception & e) {
      MIRO_LOG_OSTR(LL_CRITICAL, "Uncaught CORBA exception: " << e);
      rc = 1;
    }
  }
  catch (const Miro::CException& e) {
    MIRO_LOG_OSTR(LL_CRITICAL, "Miro C exception: " << e);
    rc = 1;
  }
  catch (const Miro::Exception& e) {
    MIRO_LOG_OSTR(LL_CRITICAL,"Miro exception: " << e);
    rc = 1;
  }
  return rc;
}
int
main(int argc, char *argv[])
{
  int rc = 0;

  // Init TAO Factories
  TAO_Notify_Default_CO_Factory::init_svc();
  TAO_Notify_Default_POA_Factory::init_svc();
  TAO_Notify_Default_Collection_Factory::init_svc();
  TAO_Notify_Default_EMO_Factory::init_svc();

  // Parameters to be passed to the services
  Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
  Pioneer::Parameters * pioneerParameters = Pioneer::Parameters::instance();

  try {
    // Config file processing
    Miro::ConfigDocument * config = new Miro::ConfigDocument(argc, argv);
    config->setSection("Robot");
    config->getParameters("Robot", *robotParameters);
    config->setSection("ActiveMedia");
    config->getParameters("PioneerBoard", *pioneerParameters);
    delete config;
    
#ifdef DEBUG
    cout << "  robot parameters:" << endl << *robotParameters << endl;
    cout << "  pioneer parameters:" << endl << *pioneerParameters << endl;
#endif
    
    DBG(cout << "Initialize server daemon." << endl);
    PioneerBase pioneerBase(argc, argv);
    try {
      DBG(cout << "Loop forever handling events." << endl);
      pioneerBase.run(8);
      DBG(cout << "pioneerBase ended, exiting." << endl);
    }
    catch (const Miro::EOutOfBounds& e) {
      cerr << "OutOfBounds exception: Wrong parameter for device initialization." << endl;
    }
    catch (const Miro::EDevIO& e) {
      cerr << "DevIO exception: Device access failed." << endl;
    }
    catch (const CORBA::Exception & e) {
      cerr << "Uncaught CORBA exception: " << e << endl;
      rc = 1;
    }
  }
  catch (const Miro::CException& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }
  catch (const Miro::Exception& e) {
    cerr << "Miro exception: " << e << endl;
    rc = 1;
  }
  catch (...) {
    cerr << "Uncaught exception: " << endl;
    rc = 1;
  }
  return rc;
}
int
main(int argc, char *argv[])
{
  int rc = 1;
  std::string fileName;

  // read syslog options
  Miro::Log::init(argc, argv);

  // Parameters to be passed to the services
  Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
  Miro::LogNotifyParameters * parameters = Miro::LogNotifyParameters::instance();

  // Config file processing
  Miro::ConfigDocument * config = 
    new Miro::ConfigDocument(argc, argv);
  config->setSection("Robot");
  config->getParameters("Robot", *robotParameters);
  config->setSection("Notification");
  config->getParameters("Logging", *parameters);
  delete config;
  
  MIRO_DBG_OSTR(MIRO , LL_PRATTLE , "  robot parameters:\n" << robotParameters);
  MIRO_DBG_OSTR(MIRO , LL_PRATTLE , "  logging parameters:\n" << parameters);

  MIRO_LOG(LL_NOTICE,"Initialize server daemon.");
  Miro::Server server(argc, argv);

  // override default logfile name with command line parameter
  if (argc > 1)
    fileName = argv[1];

  try {
    // The one channel that we create using the factory.
    CosNotifyChannelAdmin::EventChannel_var 
      ec(server.resolveName<CosNotifyChannelAdmin::EventChannel>("EventChannel"));
    
    // The consumer, that gets the events
    Miro::LogNotifyConsumer pushConsumer(server,
					 ec.in(), 
					 server.namingContextName,
					 fileName,
					 *parameters,
					 false);
    
    try {
      MIRO_LOG(LL_NOTICE , "Loop forever handling events." );
      server.run(1);
      MIRO_LOG(LL_NOTICE , "Server loop ended, exiting." );
      rc = 0;
    }
    catch (const Miro::Exception& e) {
      MIRO_LOG_OSTR(LL_CRITICAL , "Uncought Miro excepition: " << e);
    }

    server.detach(1);

    MIRO_LOG(LL_NOTICE , "shutting down server.");
    pushConsumer.disconnect();
    server.shutdown();
    server.wait();
  }
  catch (const CORBA::Exception & e) {
    MIRO_LOG_OSTR(LL_CRITICAL , "Uncaught CORBA exception: " << e);
  }
  return rc;
}
int
main(int argc, char *argv[])
{
  int rc = 1;

  // Init TAO Factories
  TAO_Notify_Default_CO_Factory::init_svc();
  TAO_Notify_Default_POA_Factory::init_svc();
  TAO_Notify_Default_Collection_Factory::init_svc();
  TAO_Notify_Default_EMO_Factory::init_svc();
    
  try {
    Miro::Log::init(argc, argv);
    Miro::Configuration::init(argc, argv);

    // Parameters to be passed to the services
    Miro::RobotParameters * robotParameters = Miro::RobotParameters::instance();
    Pioneer::Parameters * pioneerParameters = Pioneer::Parameters::instance();

    // Config file processing
    MIRO_LOG(LL_NOTICE,"Getting config document");
    Miro::ConfigDocument * config = Miro::Configuration::document();
    config->setSection("Robot");
    config->getParameters("Miro::RobotParameters", *robotParameters);
    MIRO_LOG(LL_NOTICE,"Got Robot Parameters");
    config->setSection("ActiveMedia");
    config->getParameters("Pioneer::Parameters", *pioneerParameters);
      
    MIRO_LOG_OSTR(LL_NOTICE,
		  "  robot parameters:" << std::endl <<
		  *robotParameters << std::endl <<
		  "  pioneer parameters:" << std::endl <<
		  *pioneerParameters << std::endl
		  );
      
    MIRO_LOG(LL_NOTICE, "Initialize server daemon.");
    PioneerBase pioneerBase(argc, argv);
    try {
      MIRO_LOG(LL_NOTICE, "Loop forever handling events.");
      pioneerBase.run(8);
      MIRO_LOG(LL_NOTICE, "pioneerBase ended, exiting.");
      rc = 0;
    }
    catch (const Miro::EOutOfBounds& e) {
      MIRO_LOG_OSTR(LL_CRITICAL,
		    "OutOfBounds exception: Wrong parameter for device initialization." << std::endl <<
		    e.what);
    }
    catch (const Miro::EDevIO& e) {
      MIRO_LOG_OSTR(LL_CRITICAL,
		    "DevIO exception: Device access failed." << std::endl <<
		    e.what);
    }
    catch (const CORBA::Exception & e) {
      MIRO_LOG_OSTR(LL_CRITICAL, "Uncaught CORBA exception: " << e);
    }
  }
  catch (const Miro::Exception& e) {
       MIRO_LOG_OSTR(LL_CRITICAL, "Miro exception: " << e);
       rc = 1;
  }

  return rc;
}