自学教程：C++ spinner函数代码示例

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;}

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;}

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;}

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;}

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();}

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;    }

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;}

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;}

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;}

void WebVideoServer::spin(){  server_->run();  ROS_INFO("Waiting For connections");  ros::MultiThreadedSpinner spinner(ros_threads_);  spinner.spin();  server_->stop();}

/* ---[ */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);}

/****** * 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;		}}

 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; }

int main(int argc, char **argv){  ros::init(argc, argv, "trivia_intialized");  ros::NodeHandle node_handle;  ros::AsyncSpinner spinner(1);  spinner.start();}

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;}

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;}

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();}

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;}

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;}

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;}

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;}

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		}	}	}; 

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;}

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;}

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;}

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);}

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;}

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