コード例 #1
1
ファイル: ros.cpp プロジェクト: davetcoleman/unix_settings
int main(int argc, char** argv)
{
  ros::init(argc, argv, "SHORT_NAME");
  ROS_INFO_STREAM_NAMED("main", "Starting CLASS_NAME...");

  // Allow the action server to recieve and send ros messages
  ros::AsyncSpinner spinner(2);
  spinner.start();

  // Check for verbose flag
  bool verbose = false;
  if (argc > 1)
  {
    for (int i = 0; i < argc; ++i)
    {
      if (strcmp(argv[i], "--verbose") == 0)
      {
        ROS_INFO_STREAM_NAMED("main","Running in VERBOSE mode (slower)");
        verbose = true;
        continue;
      }
    }
  }

  PACKAGE_NAME::CLASS_NAME server();

  ROS_INFO_STREAM_NAMED("main", "Shutting down.");
  ros::shutdown();

  return 0;
}
コード例 #2
0
int main(int argc, char **argv)
{
  ros::init(argc, argv, PLANNER_NODE_NAME);
  
  bool debug = false;
  for (int i = 1 ; i < argc ; ++i)
    if (strncmp(argv[i], "--debug", 7) == 0)
      debug = true;
  
  ros::AsyncSpinner spinner(1);
  spinner.start();
  
  boost::shared_ptr<tf::TransformListener> tf(new tf::TransformListener());
  planning_scene_monitor::PlanningSceneMonitor psm(ROBOT_DESCRIPTION, tf);
  if (psm.getPlanningScene())
  {
    psm.startWorldGeometryMonitor();
    psm.startSceneMonitor();
    psm.startStateMonitor();
    
    OMPLPlannerService pservice(psm, debug);
    pservice.status();
    ros::waitForShutdown();
  }
  else
    ROS_ERROR("Planning scene not configured");  
  
  return 0;
}
コード例 #3
0
int main(int argc, char** argv)
{
  // Init the ROS node
  ros::init(argc, argv, "omnirob_robin_lwa_interface");

  ros::NodeHandle n;
  ros::Rate loop_rate(100);	// 100 Hz => consistent to sampleTime
  ros::AsyncSpinner spinner(4); // Use 4 threads

  //MyRobot omniRob;
  controller_manager::ControllerManager cm(&omniRob);
  ros::Duration sampleTime(0.01);
  ros::Publisher trajectoryPoint_pub = n.advertise<std_msgs::Float64MultiArray>("lwa/control/commanded_joint_state", 1000);
  ros::Subscriber jointState_sub = n.subscribe("lwa/state/joint_state", 1000, jointState_callback);

  std_msgs::Float64MultiArray trajPoint;

  spinner.start();

  while (ros::ok())
  {
     //omniRob.read();  // automated subscription
     cm.update(ros::Time::now(), sampleTime);
     omniRob.write(trajectoryPoint_pub, trajPoint);
     ROS_INFO("omnirob LWA3 OK...");

     //ros::spinOnce();
     //ros::waitForShutdown();
     loop_rate.sleep();
     //spinner.stop();
  }
  return 0;
}
コード例 #4
0
ファイル: inhaler_gui.cpp プロジェクト: 90301/inhaler_gui
int main(int argc, char *argv[])
{
  
  mainWorkspace.clear(); 
  std::cout << "Inhaler GUI Version: " << VERSION_NUMBER << " started." << std::endl;
 ros::init (argc, argv, "inhaler_gui_server");
    QApplication app(argc, argv);
    MyWidget widget;
    
    Line l(100,100,210,200);
    lines.push_back (l);
    //ROS subscribing
    ros::NodeHandle n;
    
    ros::Subscriber lineSub = n.subscribe ("inhalerGUI_Line",1000,addLine);
    ros::Subscriber textSub = n.subscribe ("inhalerGUI_Text",1000,addText);
    ros::Subscriber clearSub = n.subscribe ("inhalerGUI_Clear",1000,clearGUI);
    
    
    widget.show();
    
    ros::AsyncSpinner spinner(4); // Use 4 threads
    spinner.start();
    //ros::waitForShutdown();
    app.exec();
    //app.exec();
    
    return 0;
}
コード例 #5
0
int main(int argc, char **argv)
{
    ros::init (argc, argv, "hsmakata_pick_n_place_demo");
    ros::NodeHandle nh;

    ros::Publisher display_publisher = nh.advertise<moveit_msgs::DisplayTrajectory>("/move_group/display_planned_path", 1, true);

    ros::AsyncSpinner spinner(1);
    spinner.start();

    pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);
    pub_aco = nh.advertise<moveit_msgs::AttachedCollisionObject>("attached_collision_object", 10);
    grasps_marker = nh.advertise<visualization_msgs::MarkerArray>("grasps_marker", 10);

    sub_point = nh.subscribe<visualization_msgs::Marker>("cup_center",1,cb_points);

    moveit::planning_interface::MoveGroup gripper("gripper");
    gripper.setNamedTarget("closed");
    gripper.move();

    moveit::planning_interface::MoveGroup katana("manipulator");
    katana.setNamedTarget("home");
    katana.move();


    ros::spin();


}
コード例 #6
0
int main(int argc, char **argv) {
    ros::init (argc, argv, "left_arm_pick_place");
    ros::AsyncSpinner spinner(1);
    spinner.start();


    ros::NodeHandle nh;


    ros::Publisher pub_co = nh.advertise<moveit_msgs::CollisionObject>("collision_object", 10);

    ros::WallDuration(10.0).sleep();


    // moveit::planning_interface::MoveGroup armgroup = group;

    // addCollisionObjects(pub_co);

    // wait a bit for ros things to initialize
    // ros::WallDuration(1.0).sleep();
    // ROS_INFO("I should plan now");
    // pick(group);
    // ROS_INFO("planned");
    //
    positionService = nh.advertiseService("armPosition", &setPosition);

    ros::spin();
    return 0;
    }
コード例 #7
0
/**
 * progress - Advanced ASCII progress bar with spinner
 * @percent: Start first call with this set to 0, end with 100
 * @max_width: Max width of progress bar, in total characters.
 *
 * This function draws an advanced ASCII progressbar at the current
 * line.  It always start from the first column.
 *
 * The progress bar will hide the cursor if started with @percent 0 and
 * show it again at the end, when called with @percent 100.
 *
 * While being called with the same percentage the spinner will spin,
 * to show the user the process hasn't frozen.
 *
 * If the output TTY cannot interpret control characters, like \r, it is
 * advised to instead used the progress_simple() function.
 */
void progress(int percent, int max_width)
{
	int i, bar;

	/* Adjust for progress bar overhead */
	max_width -= 10;

	if (0 == percent)
		hidecursor();

	fprintf(stderr, "\r%3d%% %c [", percent, spinner(NULL));

	bar = percent * max_width / 100;
	for (i = 0; i < max_width; i++) {
		if (i > bar)
			fputc(' ', stderr);
		else if (i == bar)
			fputc('>', stderr);
		else
			fputc('=', stderr);
	}

	fprintf(stderr, "]");
	if (100 == percent) {
		showcursor();
		fputc('\n', stderr);
	}
}
コード例 #8
0
int main(int argc, char** argv) {

	MoveKuka kukaObj;

  kukaObj.q.resize(5);
  kukaObj.qArmPosition.resize(5);
  kukaObj.qArmHome.resize(5);
  kukaObj.gripperJointPositions.resize(2);

  kukaObj.gripperJointPositions[0].joint_uri = "gripper_finger_joint_l";
  kukaObj.gripperJointPositions[0].unit = boost::units::to_string(boost::units::si::meters);
        
  kukaObj.gripperJointPositions[1].joint_uri = "gripper_finger_joint_r";
  kukaObj.gripperJointPositions[1].unit = boost::units::to_string(boost::units::si::meters);

  ros::init(argc, argv, "mahni");
  ros::NodeHandle nh;
  ros::Subscriber subArmActionResult = nh.subscribe("arm_1/arm_controller/follow_joint_trajectory/result", 1000, &MoveKuka::ArmResultListener, &kukaObj);
  ros::Subscriber subJointStates = nh.subscribe("joint_states", 1000, &MoveKuka::UpdateRobotPose, &kukaObj);
  
  kukaObj.armTrajectoryPublisher = nh.advertise< control_msgs::FollowJointTrajectoryActionGoal > ("arm_1/arm_controller/follow_joint_trajectory/goal",1);

  kukaObj.gripperPositionPublisher = nh.advertise< brics_actuator::JointPositions > ("arm_1/gripper_controller/position_command", 1);

  ros::ServiceServer serviceGoHome  = nh.advertiseService("move", &MoveKuka::Move, &kukaObj);
  ros::ServiceServer serviceGoRight = nh.advertiseService("go_home", &MoveKuka::GoHome, &kukaObj);
  
	ros::ServiceServer serviceOpenGripper  = nh.advertiseService("open_gripper", &MoveKuka::OpenGripper, &kukaObj);
  ros::ServiceServer serviceCloseGripper = nh.advertiseService("close_gripper", &MoveKuka::CloseGripper, &kukaObj);

  ros::MultiThreadedSpinner spinner(4); // Use 4 threads
  spinner.spin(); // spin() will not return until the node has been shutdown

  return 0;
}
コード例 #9
0
ファイル: cob_light.cpp プロジェクト: ipa-josh/cob_driver
int main(int argc, char** argv)
{
	// init node
	ros::init(argc, argv, "light_controller", ros::init_options::NoSigintHandler);
	signal(SIGINT, sigIntHandler);

	// Override XMLRPC shutdown
	ros::XMLRPCManager::instance()->unbind("shutdown");
	ros::XMLRPCManager::instance()->bind("shutdown", shutdownCallback);

	// create LightControl instance
	LightControl *lightControl = new LightControl();

	ros::AsyncSpinner spinner(1);
  	spinner.start();

  	while (!gShutdownRequest)
  	{
		ros::WallDuration(0.05).sleep();
	}

  	delete lightControl;

  	ros::shutdown();

	return 0;
}
コード例 #10
0
ファイル: binlog.c プロジェクト: fhgwright/gpsd
int main(int argc, char **argv) {
	int speed, n, ifd, ofd;
	struct termios term;
	char buf[BUFSIZ];
	struct timespec delay;

	if (argc != 4){
		fprintf(stderr, "usage: binlog <speed> <port> <logfile>\n");
		return 1;
	}

	speed = atoi(argv[1]);
	switch (speed) {
	case 230400:
	case 115200:
	case 57600:
	case 38400:
	case 28800:
	case 19200:
	case 14400:
	case 9600:
	case 4800:
		break;
	default:
		fprintf(stderr, "invalid speed\n");
		return 1;
	}

	if ((ifd = open(argv[2], O_RDWR | O_NONBLOCK | O_NOCTTY, 0644)) == -1)
		err(1, "open");

	if ((ofd = open(argv[3], O_RDWR | O_CREAT | O_APPEND, 0644)) == -1)
		err(1, "open");

	tcgetattr(ifd, &term);
	cfmakeraw(&term);
	cfsetospeed(&term, speed);
	cfsetispeed(&term, speed);
	if (tcsetattr(ifd, TCSANOW | TCSAFLUSH, &term) == -1)
		err(1, "tcsetattr");

	tcflush(ifd, TCIOFLUSH);
	n = 0;
	while (1){
		int l = read(ifd, buf, BUFSIZ);
		if (l > 0)
		    assert(write(ofd, buf, l) > 0);
		/* wait 1,000 uSec */
		delay.tv_sec = 0;
		delay.tv_nsec = 1000000L;
		nanosleep(&delay, NULL);
		memset(buf, 0, BUFSIZ);
		spinner( n++ );
	}
	/* NOTREACHED */
	close(ifd);
	close(ofd);
	return 0;
}
コード例 #11
0
void WebVideoServer::spin()
{
  server_->run();
  ROS_INFO("Waiting For connections");
  ros::MultiThreadedSpinner spinner(ros_threads_);
  spinner.spin();
  server_->stop();
}
コード例 #12
0
ファイル: main.cpp プロジェクト: ChellaVignesh/ros_haptics
/* ---[ */
int main (int argc, char* argv[])
{
  ros::init(argc, argv, "haptics_node");
  HapticNode haptics(argv);
  ros::MultiThreadedSpinner spinner(3); // Use 4 threads
  spinner.spin();

  return (0);
}
コード例 #13
0
ファイル: xbmc-splash.c プロジェクト: Bobbin007/xbmc
/******
 * Animation callback - called 25 times per second by Usplash 
 * 
 * Param:	struct usplash_theme* theme	- theme being used 
 * 			int pulsating - boolean int
 */
void t_animate_step(struct usplash_theme* theme, int pulsating) {
	current_count = current_count + 1;
	
	// increase test int for slower spinning
	if(current_count == spinner_speed) {
		spinner(theme);
		current_count = 0;	
	}
}
コード例 #14
0
 int main(int argc, char **argv)
 {
   ros::init (argc, argv, "ar_viz_servo");
   ros::AsyncSpinner spinner(1);
   spinner.start();
   VisualServo vizual_servo;
   ros::shutdown();
   return 0;
 }
コード例 #15
0
ファイル: trivia_database.cpp プロジェクト: zl87/tangy_legacy
int main(int argc, char **argv)
{

  ros::init(argc, argv, "trivia_intialized");
  ros::NodeHandle node_handle;
  ros::AsyncSpinner spinner(1);
  spinner.start();

}
コード例 #16
0
ファイル: main.cpp プロジェクト: chinjao/ros_src
int main(int argc, char** argv){
  thread thr_check(&check);
  ros::init(argc, argv, "speech_recog");
  SpeechRecog SRObject;
  ros::MultiThreadedSpinner spinner(3); // Use 3 threads
  spinner.spin(); 
  //ros::spin();
  return 0;
}
コード例 #17
0
int main(int argc, char** argv)
{
	ros::init(argc, argv, "product_manager");
	ros::NodeHandle node;
	ros::AsyncSpinner spinner(1);
	spinner.start();
	ProductManager productManager(node);
	productManager.run();
	return 0;
}
コード例 #18
0
int main(int argc, char **argv)
{
  testing::InitGoogleTest(&argc, argv);

  ros::init(argc, argv, "test_ompl_planning", ros::init_options::AnonymousName);
  ros::AsyncSpinner spinner(1);
  spinner.start();

  return RUN_ALL_TESTS();
}
コード例 #19
0
int main(int argc, char **argv)
{
	ros::init (argc, argv, "move_group_tutorial");
	ros::NodeHandle node_handle("~");
	ros::AsyncSpinner spinner(1);
	spinner.start();

	sleep(20.0);

	moveit::planning_interface::MoveGroup group("arm");

	moveit::planning_interface::PlanningSceneInterface planning_scene_interface; 

	ros::Publisher display_publisher = node_handle.advertise<moveit_msgs::DisplayTrajectory>("/move_group/display_planned_path", 1, true);
	moveit_msgs::DisplayTrajectory display_trajectory;

	ROS_INFO("Reference frame: %s", group.getPlanningFrame().c_str());

	ROS_INFO("Reference frame: %s", group.getEndEffectorLink().c_str());

	geometry_msgs::PoseStamped target_pose1;
	
	target_pose1.header.frame_id = "odom";
	target_pose1.pose.position.x = 0.128518;
	target_pose1.pose.position.y = -0.132719;
	target_pose1.pose.position.z = 0.321876;
	target_pose1.pose.orientation.w = 0.0125898;
	target_pose1.pose.orientation.x = 0.184773;
	target_pose1.pose.orientation.y = -0.980428;
	target_pose1.pose.orientation.z = -0.0667877;
		
	group.setPoseTarget(target_pose1);

	moveit::planning_interface::MoveGroup::Plan my_plan;
	bool success = group.plan(my_plan);

	ROS_INFO("Visualizing plan 1 (pose goal) %s",success?"":"FAILED"); 

	sleep(5.0);

	if (1)
	{
		ROS_INFO("Visualizing plan 1 (again)");
		display_trajectory.trajectory_start = my_plan.start_state_;
		display_trajectory.trajectory.push_back(my_plan.trajectory_);
		display_publisher.publish(display_trajectory);
		/* Sleep to give Rviz time to visualize the plan. */
		sleep(5.0);
	}

	ros::shutdown();
	return 0;

	return 0;
}
コード例 #20
0
ファイル: main.cpp プロジェクト: cpaxton/iiwa_stack
int main( int argc, char** argv ) {
  // initialize ROS
  ros::init(argc, argv, "iiwa_hw", ros::init_options::NoSigintHandler);
  
  // ros spinner
  ros::AsyncSpinner spinner(1);
  spinner.start();
  
  // custom signal handlers
  signal(SIGTERM, quitRequested);
  signal(SIGINT, quitRequested);
  signal(SIGHUP, quitRequested);
  
  // construct the lbr iiwa
  ros::NodeHandle iiwa_nh;
  IIWA_HW iiwa_robot(iiwa_nh);
  
  // configuration routines
  iiwa_robot.start();
  
  ros::Time last(ros::Time::now());
  ros::Time now;
  ros::Duration period(1.0);
  
  //the controller manager
  controller_manager::ControllerManager manager(&iiwa_robot, iiwa_nh);
  
  // run as fast as possible
  while( !g_quit ) {
    
    // get the time / period
    now = ros::Time::now();
    period = now - last;
    last = now;
    
    // read current robot position
    iiwa_robot.read(period);
    
    // update the controllers
    manager.update(now, period);
    
    // send command position to the robot
    iiwa_robot.write(period);
    
    // wait for some milliseconds defined in controlFrequency
    iiwa_robot.getRate()->sleep();
  }
  
  std::cerr << "Stopping spinner..." << std::endl;
  spinner.stop();
  
  std::cerr << "Bye!" << std::endl;
  
  return 0;
}
コード例 #21
0
ファイル: lift_torso.cpp プロジェクト: GKIFreiburg/pr2_tidyup
int main(int argc, char **argv)
{
	ros::init(argc, argv, "lift_torso");

	ros::NodeHandle nh;
	ros::AsyncSpinner spinner(1);
	spinner.start();

	double position;
	if (argc != 2)
	{
		ROS_ERROR("Usage: rosrun control_robot lift_torso <torso_position>");
		return 1;
	}
	position = atof(argv[1]);
	ROS_INFO("Set torso position to %lf", position);

	moveit::planning_interface::MoveGroup torso_group("torso");
	std::vector<std::string> torso_joints = torso_group.getJoints();
	ROS_ASSERT(torso_joints.size() > 0);
	if (!torso_group.setJointValueTarget(torso_joints[0], position))
	{
		ROS_ERROR("Position out of bounds - not moving torso");
		return 1;
	}
	moveit::planning_interface::MoveItErrorCode error_code;
	ROS_INFO("Lifting torso...");
	error_code = torso_group.move();
	ros::shutdown();
	return error_code == moveit::planning_interface::MoveItErrorCode::SUCCESS;

//	//ros::ServiceClient torso_client = nh.serviceClient<control_robot_msgs::MoveIt>("/control_robot/torso_lift_max");
//	ros::ServiceClient torso_client = nh.serviceClient<control_robot_msgs::MoveItPosition>("/control_robot/torso_lift");
//	control_robot_msgs::MoveItPosition srv;
//	srv.request.position.data = position;
//
//	ROS_INFO("Wait for existence of service: %s", torso_client.getService().c_str());
//	torso_client.waitForExistence();
//
//	if (!torso_client.exists())
//		ROS_ERROR("Client %s does not exist.", torso_client.getService().c_str());
//
//	ROS_INFO("Lifting torso...");
//
//	if (!torso_client.call(srv))
//	{
//		ROS_ERROR("Could not send service message to client: %s", torso_client.getService().c_str());
//		return 1;
//	}
//	ROS_INFO("Service call for torso was successful.");

//	ros::shutdown();
//	return 0;

}
コード例 #22
0
int main(int argc, char **argv)
{
	MyApp app(argc, argv);

	ros::init(argc,argv,"ros_episodic_memory_viz");
	ros::NodeHandle node;

	// Catch ctrl-c to close the gui
	// (Place this after QApplication's constructor)
	struct sigaction sigIntHandler;
	sigIntHandler.sa_handler = my_handler;
	sigemptyset(&sigIntHandler.sa_mask);
	sigIntHandler.sa_flags = 0;
	sigaction(SIGINT, &sigIntHandler, NULL);

	ROS_NetworkVisualizer w(&node);

	//subscribe to topic to receive changes from the core
	ros::Subscriber updatedWeightSubscriber = node.subscribe("updated_weight",10000,&ROS_NetworkVisualizer::updatedWeightSubscriber,&w);
	ros::Subscriber newCategory = node.subscribe("new_category",1000, &ROS_NetworkVisualizer::newCategorySubscriber, &w);
	ros::Subscriber categoryActivation = node.subscribe("category_activation",1000, &ROS_NetworkVisualizer::updateActivationSubscriber, &w);
	ros::Subscriber newChannel = node.subscribe("new_channel",100, &ROS_NetworkVisualizer::newChannelSubscriber, &w);
	ros::Subscriber anticipatedEvent = node.subscribe("anticipated_event",100, &ROS_NetworkVisualizer::anticipatedEventSubscriber, &w);
	ros::Subscriber learningModeChange = node.subscribe("change_learning_mode",5, &ROS_NetworkVisualizer::learningModeChangeSubscriber,&w);
	//subscribe to emotions
	ros::Subscriber emotionSub = node.subscribe("emotions",100,&ROS_NetworkVisualizer::callbackEmotion, &w);

	//publisher
	ros::Publisher pubInputData = node.advertise<ros_episodic_memory::inputData>("input_data",1000,false);
	w.setInputDataPublisher(&pubInputData);
	ros::Publisher pubLearningMode = node.advertise<ros_episodic_memory::learningMode>("force_change_learning_mode",5,false);
	w.setLearningModePublisher(&pubLearningMode);

	w.show();
	app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));

	ros::AsyncSpinner spinner(0);
	spinner.start();

	ros::Duration(0.5).sleep();

	//use service provided by ros_episodic_memory node to initialize visualizer
	ros::ServiceClient client = node.serviceClient<std_srvs::Empty>("get_initial_values");
	std_srvs::Empty empty;
	if(!client.call(empty))
	{
		ROS_WARN("Warning, call to service provided by ros_episodic_memory returns nothing");
	}

	int result = app.exec();
	spinner.stop();
	w.joinBackgroundThread();

	return result;
}
コード例 #23
0
int main (int argc, char **argv) {
	
	// Initialize ROS
	ros::init(argc, argv, "CommandRobot");
	ros::NodeHandle nh("~");
	
	// ROS spinner.
	ros::AsyncSpinner spinner(1);
	spinner.start();
  
  iiwa_ros::iiwaRos my_iiwa;
  my_iiwa.init();
	
	// Dynamic parameters. Last arg is the default value. You can assign these from a launch file.
  bool use_cartesian_command;
	nh.param("use_cartesian_command", use_cartesian_command, true);
	
	// Dynamic parameter to choose the rate at wich this node should run
  double ros_rate;
	nh.param("ros_rate", ros_rate, 0.1); // 0.1 Hz = 10 seconds
	ros::Rate* loop_rate_ = new ros::Rate(ros_rate);
  
  geometry_msgs::PoseStamped command_cartesian_position;
  iiwa_msgs::JointPosition command_joint_position;
  bool new_pose = false, motion_done = false;
  
	int direction = 1;
	
	while (ros::ok()) {
    if (my_iiwa.getRobotIsConnected()) {
			
			if (use_cartesian_command) {
        while (!my_iiwa.getCartesianPose(command_cartesian_position)) {}
				// Here we set the new commanded cartesian position, we just move the tool TCP 10 centemeters down and back up, every 10 seconds.
				command_cartesian_position.pose.position.z -= direction * 0.10;
				my_iiwa.setCartesianPose(command_cartesian_position);				
			} else {
        while (!my_iiwa.getJointPosition(command_joint_position)) {}
        command_joint_position.position.a4 -= direction * 5 * M_PI / 180; // 0.0872665 // Adding/Subtracting 5 degrees (in radians) to the 4th joint
				my_iiwa.setJointPosition(command_joint_position);
			}
			
			sleepForMotion(my_iiwa, 2.0);
			
			direction *= -1; // In the next iteration the motion will be on the opposite direction
			
			loop_rate_->sleep(); // Sleep for some millisecond. The while loop will run every 10 seconds in this example.
		}
		else {
			ROS_WARN_STREAM("Robot is not connected...");
			ros::Duration(5.0).sleep(); // 5 seconds
		}
	}	
}; 
コード例 #24
0
int main(int argc, char** argv)
{
  ros::init(argc, argv, "environment_server");
  //figuring out whether robot_description has been remapped

  ros::AsyncSpinner spinner(1); 
  spinner.start();
  planning_environment::EnvironmentServer environment_monitor;
  ros::waitForShutdown();
  return 0;
}
コード例 #25
0
int main(int argc, char **argv)
{ 
  // Parse parameters
  namespace po = boost::program_options;

  // Declare the supported options
  po::options_description desc("Allowed options");
  desc.add_options()
    ("help", "Show help message")
    ("debug", "Run in debug/test mode")
    ("urdf_path", po::value<std::string>(), "Optional, relative path to URDF in URDF package")
    ("config_pkg", po::value<std::string>(), "Optional, pass in existing config package to load");

  // Process options
  po::variables_map vm;
  po::store(po::parse_command_line(argc, argv, desc), vm);
  po::notify(vm);    

  if (vm.count("help"))
  {
    std::cout << desc << std::endl;
    return 1;
  }

  // Start ROS Node
  ros::init(argc, argv, "moveit_setup_assistant", ros::init_options::NoSigintHandler);

  // ROS Spin
  ros::AsyncSpinner spinner(1);
  spinner.start();

  ros::NodeHandle nh;

  // Create Qt Application
  QApplication qtApp(argc, argv);

  // Load Qt Widget
  moveit_setup_assistant::SetupAssistantWidget saw( NULL, vm );
  saw.setMinimumWidth(1024);
  saw.setMinimumHeight(768);
  //  saw.setWindowState( Qt::WindowMaximized );

  saw.show();

  signal(SIGINT, siginthandler);

  // Wait here until Qt App is finished
  const int result = qtApp.exec();

  // Shutdown ROS
  ros::shutdown();    

  return result;
}
コード例 #26
0
int main(int argc, char **argv) {
  ros::init(argc, argv, "test_joystick_driver");
  testing::InitGoogleTest(&argc, argv);

  ros::AsyncSpinner spinner(1);
  spinner.start();
  int ret = RUN_ALL_TESTS();
  spinner.stop();
  ros::shutdown();
  return ret;
}
コード例 #27
0
int main(int argc, char *argv[])
{
  ROS_INFO_STREAM_NAMED("main","Starting baxter control test for finger sensor...");
  ros::init(argc, argv, "baxter_control_test");
  ros::AsyncSpinner spinner(2);
  spinner.start();

  int test = 1;
  ros_finger_sensor::BaxterControlTest tester(test);

}
コード例 #28
0
int main(int argc, char **argv)
{
  ros::init(argc, argv, "current_state_validator");

  ros::AsyncSpinner spinner(1); // Use 2 threads
  spinner.start();
  
  CurrentStateValidator cko;
  ros::waitForShutdown();
  
  return 0;
}
int main(int argc, char** argv)
{
  testing::InitGoogleTest(&argc, argv);
  ros::init(argc, argv, "diff_drive_odom_frame_test");

  ros::AsyncSpinner spinner(1);
  spinner.start();
  int ret = RUN_ALL_TESTS();
  spinner.stop();
  ros::shutdown();
  return ret;
}
コード例 #30
0
//============= Main function of test runer ===================================
int main(int argc, char **argv) {
    
    testing::InitGoogleTest(&argc, argv);
    ros::init(argc, argv, "trajectory_generator_testFunctionality_runner");    
    ros::AsyncSpinner spinner(1);
    spinner.start();
    int result = RUN_ALL_TESTS();
    spinner.stop();
    ros::shutdown();
    return result;
    
}