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