int
main (int argc, char **argv)
{
if (argc < 2)
exit(printf("Use %s <rddf-file>\n", argv[0]));
carmen_rddf_filename = argv[1];
setlocale(LC_ALL, "C");
signal(SIGINT, carmen_rddf_build_shutdown_module);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
carmen_rddf_build_get_parameters(argc, argv);
carmen_rddf_play_open_kml();
carmen_localize_ackerman_subscribe_globalpos_message(
NULL, (carmen_handler_t) localize_globalpos_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_ipc_addPeriodicTimer(1.0, (TIMER_HANDLER_TYPE) carmen_rddf_timer_handler,
carmen_rddf_filename);
carmen_ipc_dispatch();
return (0);
}
int
main(int argc, char** argv)
{
double length;
char *dev;
int num_items;
char **modules;
int num_modules;
carmen_param_t param_list[] = {
{"robot", "length", CARMEN_PARAM_DOUBLE, &length, 1, handler},
{"scout", "dev", CARMEN_PARAM_STRING, &dev, 1, handler},
};
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
num_items = sizeof(param_list)/sizeof(param_list[0]);
carmen_param_install_params(argc, argv, param_list, num_items);
carmen_param_get_robot();
carmen_param_get_modules(&modules, &num_modules);
carmen_warn("robot_length is %.1f\n", length);
carmen_warn("scout_dev is %s\n", dev);
carmen_param_check_unhandled_commandline_args(argc, argv);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
if (argc == 3 && !strcmp("ultrasonic",argv[2]))
read_ultrasonic_sensor_parameters(argc, argv, &laser_params, &map_params);
else
read_laser_parameters(argc, argv, &laser_params, &map_params);
initialize_transforms();
/* Create and initialize a probabilistic map */
init_carmen_map(&map_params, &carmen_map);
init_bean_range_finder_measurement_model(laser_params);
/* Register my own messages */
carmen_grid_mapping_define_messages();
carmen_subscribe_to_relevant_messages();
/* Loop forever waiting for messages */
carmen_ipc_dispatch();
return (0);
}
int
main( int argc, char *argv[] )
{
/* Connect to IPC Server */
carmen_ipc_initialize(argc, argv);
/* Check the param server version */
carmen_param_check_version(argv[0]);
/* Register shutdown cleaner handler */
signal(SIGINT, shutdown_module);
carmen_gps_xyz_define_message();
carmen_xsens_xyz_define_message();
carmen_velodyne_gps_xyz_define_message();
/* Subscribe to sensor messages */
carmen_gps_subscribe_nmea_message(NULL, (carmen_handler_t) ipc_gps_gpgga_handler, CARMEN_SUBSCRIBE_ALL);
carmen_xsens_mtig_subscribe_message(NULL, (carmen_handler_t) xsens_mtig_handler, CARMEN_SUBSCRIBE_ALL);
carmen_velodyne_subscribe_gps_message(NULL, (carmen_handler_t) velodyne_gps_handler, CARMEN_SUBSCRIBE_ALL);
/* Loop forever waiting for messages */
carmen_ipc_dispatch();
return(0);
}
int
main(int argc, char **argv)
{
/* Connect to IPC Server */
carmen_ipc_initialize(argc, argv);
/* Check the param server version */
carmen_param_check_version(argv[0]);
/* Register shutdown cleaner handler */
signal(SIGINT, shutdown_module);
initialize_fused_odometry_message_list(100);
mapper = new Mapper2D(1000, 3000, 0.1f);
/* Define messages that your module publishes */
//carmen_skeleton_module_filter_define_messages();
/* Subscribe to sensor messages */
carmen_velodyne_subscribe_partial_scan_message(NULL, (carmen_handler_t) carmen_velodyne_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_fused_odometry_subscribe_fused_odometry_message(NULL, (carmen_handler_t) carmen_fused_odometry_handler, CARMEN_SUBSCRIBE_LATEST);
/* Loop forever waiting for messages */
carmen_ipc_dispatch();
return (0);
}
int main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
carmen_segway_subscribe_pose_message(NULL,
(carmen_handler_t)segway_pose_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char **argv)
{
/* connect to the IPC server, regsiter messages */
carmen_ipc_initialize(argc, argv);
carmen_proccontrol_subscribe_output_message(NULL, (carmen_handler_t)
output_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char *argv[])
{
signal(SIGINT, shutdown_module);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
carmen_kinect_define_kinect_messages(0);
initialize_module_args(argc, argv);
carmen_ipc_dispatch();
return(0);
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
//carmen_param_check_version(argv[0]);
while(1)
printf ("%lf\n", carmen_get_time());
carmen_ipc_dispatch();
return 0;
}
int
main (int argc, char **argv)
{
carmen_ipc_initialize (argc, argv);
signal (SIGINT, carmen_web_cam_test_shutdown_module);
cvNamedWindow("img", CV_WINDOW_AUTOSIZE);
carmen_web_cam_subscribe_message(NULL,
(carmen_handler_t) carmen_web_cam_handler,
CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
read_parameters(argc, argv, &car_config);
carmen_localize_ackerman_subscribe_globalpos_message(&globalpos, NULL, CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_addPeriodicTimer(0.1, (TIMER_HANDLER_TYPE) build_points_vector_handler, NULL);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char **argv)
{
/* Connect to IPC Server */
carmen_ipc_initialize(argc, argv);
/* Check the param server version */
carmen_param_check_version(argv[0]);
/* Initialize vector of readings laser */
/* Initialize vector of static points */
/* Initialize all the relevant parameters */
read_parameters(argc, argv);
/* Register shutdown cleaner handler */
signal(SIGINT, shutdown_module);
/* Define messages that your module publishes */
carmen_moving_objects_point_clouds_define_messages();
/* Subscribe to sensor and filter messages */
carmen_localize_ackerman_subscribe_globalpos_message(NULL,
(carmen_handler_t) localize_ackerman_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_velodyne_subscribe_partial_scan_message(NULL,
(carmen_handler_t) velodyne_partial_scan_message_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_stereo_velodyne_subscribe_scan_message(8, NULL,
(carmen_handler_t)velodyne_variable_scan_message_handler, CARMEN_SUBSCRIBE_LATEST);
// carmen_localize_ackerman_subscribe_globalpos_message(NULL,
// (carmen_handler_t) localize_ackerman_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_map_server_subscribe_offline_map(NULL,
(carmen_handler_t) carmen_map_server_offline_map_message_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_dispatch();
return (0);
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
carmen_navigator_spline_define_messages();
carmen_tracker_define_message_position();
carmen_rddf_subscribe_road_profile_message(NULL, (carmen_handler_t) rddf_message_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_localize_ackerman_subscribe_globalpos_message(NULL, (carmen_handler_t) localize_globalpos_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_tracker_subscribe_position_message(NULL,(carmen_handler_t) tracker_position_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_addPeriodicTimer(1 / 2, (TIMER_HANDLER_TYPE) periodic_publish_spline_path_message, NULL);
carmen_ipc_dispatch();
return (0);
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
read_parameters(argc, argv);
carmen_visual_tracker_define_messages();
carmen_visual_tracker_subscribe_messages();
carmen_ipc_dispatch();
return (0);
}
int main(int argc, char **argv)
{
/* Do Carmen Initialization*/
carmen_ipc_initialize(argc, argv);
/* Check the param server version */
carmen_param_check_version(argv[0]);
/* Register shutdown cleaner handler */
signal(SIGINT, shutdown_module);
/* Subscribe to sensor messages */
carmen_bumblebee_basic_subscribe_stereoimage1(NULL, (carmen_handler_t) bumblebee_message_handler, CARMEN_SUBSCRIBE_ALL);
/* Main loop */
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char** argv)
{
signal(SIGINT, shutdown_module);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
initialize_structures();
read_parameters(argc, argv, car_config);
initialize_ipc();
subscribe_to_relevant_messages();
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char** argv)
{
argc_g = argc;
argv_g = argv;
carmen_fused_odometry_parameters fused_odometry_parameters;
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
initialize_carmen_parameters(argc, argv, &fused_odometry_parameters);
register_ipc_messages();
carmen_fused_odometry_initialize(&fused_odometry_parameters);
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char **argv)
{
char filename[1024];
char key;
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
if(argc < 2)
carmen_die("usage: %s <logfile>\n", argv[0]);
sprintf(filename, "%s", argv[1]);
outfile = carmen_fopen(filename, "r");
if (outfile != NULL) {
fprintf(stderr, "Overwrite %s? ", filename);
scanf("%c", &key);
if (toupper(key) != 'Y')
exit(-1);
carmen_fclose(outfile);
}
outfile = carmen_fopen(filename, "w");
if(outfile == NULL)
carmen_die("Error: Could not open file %s for writing.\n", filename);
carmen_logwrite_write_header(outfile);
carmen_robot_subscribe_frontlaser_message(NULL,
(carmen_handler_t)robot_frontlaser_handler,
CARMEN_SUBSCRIBE_ALL);
localize_msg = (carmen_localize_globalpos_message *)
calloc(1, sizeof(carmen_localize_globalpos_message));
carmen_test_alloc(localize_msg);
carmen_localize_subscribe_globalpos_message(localize_msg, NULL, CARMEN_SUBSCRIBE_ALL);
logger_starttime = carmen_get_time();
signal(SIGINT, shutdown_module);
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char **argv)
{
/* Connect to IPC Server */
carmen_ipc_initialize(argc, argv);
/* Check the param server version */
carmen_param_check_version(argv[0]);
/* Register shutdown cleaner handler */
signal(SIGINT, shutdown_module);
/* Read application specific parameters (Optional) */
read_parameters(argc, argv);
//Initialize relevant variables
parking_assistant_initialize();
carmen_subscribe_to_relevant_messages();
/* Define published messages by your module */
carmen_parking_assistant_define_messages();
/*
carmen_behavior_selector_state_message state;
state.goal_source = CARMEN_BEHAVIOR_SELECTOR_USER_GOAL;
state.algorithm = CARMEN_BEHAVIOR_SELECTOR_A_STAR;
state.state = BEHAVIOR_SELECTOR_PARKING;
state.parking_algorithm = CARMEN_BEHAVIOR_SELECTOR_A_STAR;
state.following_lane_algorithm = CARMEN_BEHAVIOR_SELECTOR_RRT;
state.timestamp = carmen_get_time();
state.host = carmen_get_host();
publish_carmen_selector_state_message(&state);
*/
/* Loop forever waiting for messages */
carmen_ipc_dispatch();
carmen_ipc_disconnect();
return 0;
}
int main(int argc, char **argv)
{
unsigned long mtCount;
/* initialize carmen */
//carmen_randomize(&argc, &argv);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
mode = 6;
settings = 2;
const char* pName = NULL;
read_parameters(argc, argv);
pName = dev;
packet = new xsens::Packet((unsigned short) mtCount, cmt3.isXm());
/* Initializing Xsens */
initializeXsens(cmt3, mode, settings, mtCount, (char*)pName);
/* Setup exit handler */
signal(SIGINT, shutdown_xsens);
/* register localize related messages */
// register_ipc_messages();
carmen_xsens_define_messages();
while(1){
getDataFromXsens(cmt3, packet, mode, settings, g_data);
publish_xsens_global(g_data, /*mode,*/ settings);
sleep(0.1);
}
/* Loop forever */
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
if (argc < 5)
carmen_die("usage: %s <joint1 position> <joint2 position> <joint3 position> <joint4 position>\n", argv[0]);
joints[0] = atof(argv[1]);
joints[1] = atof(argv[2]);
joints[2] = atof(argv[3]);
joints[3] = atof(argv[4]);
carmen_arm_command(num_joints, joints);
carmen_arm_subscribe_state_message(NULL, (carmen_handler_t) arm_state_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char **argv)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
read_parameters(argc, argv);
if (carmen_navigator_ackerman_initialize_ipc() < 0)
carmen_die("Error: could not connect to IPC Server\n");
signal(SIGINT, navigator_shutdown);
carmen_map_server_subscribe_compact_cost_map(NULL, (carmen_handler_t) map_server_compact_cost_map_message_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_behavior_selector_subscribe_goal_list_message(NULL, (carmen_handler_t) goal_list_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_behavior_selector_subscribe_current_state_message(NULL, (carmen_handler_t) state_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_localize_ackerman_subscribe_globalpos_message(NULL, (carmen_handler_t)localize_globalpos_handler, CARMEN_SUBSCRIBE_LATEST);
carmen_ipc_dispatch();
return 0;
}
int
main(int argc, char** argv)
{
argc_g = argc;
argv_g = argv;
carmen_fused_odometry_parameters fused_odometry_parameters;
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
initialize_carmen_parameters(argc, argv, &fused_odometry_parameters);
register_ipc_messages();
carmen_fused_odometry_initialize(&fused_odometry_parameters);
// carmen_ipc_addPeriodicTimer(1.0 / fused_odometry_frequency, (TIMER_HANDLER_TYPE) correct_fused_odometry_timming_and_publish, NULL);
carmen_ipc_dispatch();
// fused_odometry_main_loop();
return 0;
}
int
main(int argc, char **argv)
{
signal(SIGINT, signal_handler);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
define_messages();
//read_parameters(argc, argv);
//select_wave_form();
carmen_ipc_addPeriodicTimer(timer_period, timer_handler, NULL);
//build_trajectory_stop_smooth_trajectory_phi();
//carmen_ipc_addPeriodicTimer(timer_period, phi_handler, NULL);
//carmen_ipc_addPeriodicTimer(4.0, vel_handler, NULL);
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char *argv[])
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
if (argc >= 6)
{
globalpos.x = atof(argv[1]);
globalpos.y = atof(argv[2]);
globalpos.theta = atof(argv[3]);
goalpos.x = atof(argv[4]);
goalpos.y = atof(argv[5]);
goalpos.theta = atof(argv[6]);
carmen_ipc_addPeriodicTimer(1, periodic_publish_globalpos, NULL);
carmen_ipc_addPeriodicTimer(1, periodic_publish_goal, NULL);
carmen_ipc_dispatch();
}
printf("parametros insuficientes\n");
return 0;
}
int
main(int argc, char **argv)
{
rrt_parking = new RRT_Parking();
rrt_lane = new RRT_Lane();
selected_rrt = rrt_lane;
rrt_lane->set_change_path_condition(0.8, carmen_degrees_to_radians(8));
rrt_lane->set_stop_condition(0.8, carmen_degrees_to_radians(30));
rrt_parking->set_change_path_condition(0.8, carmen_degrees_to_radians(8));
rrt_parking->set_stop_condition(1.0, carmen_degrees_to_radians(10));
rrt_parking->set_max_distance_grad(12.0);
rrt_parking->set_distance_near(12.0);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
read_parameters(argc, argv);
Ackerman::init_search_parameters();
rs_init_parameters(GlobalState::robot_config.max_phi, GlobalState::robot_config.distance_between_front_and_rear_axles);
GlobalState::lane_points = Lane::get_street(GlobalState::rddf_path);
RRT_IPC::register_handlers();
printf("===============RRT Parameters===============\n");
printf("Timeout: %f s\n", GlobalState::timeout);
printf("Max distance interval %f m\n", GlobalState::distance_interval);
printf("Use pose from simulator: %s\n", GlobalState::cheat ? "Yes" : "No");
carmen_ipc_dispatch();
return 0;
}
int main(int argc, char **argv)
{
char filename[1024];
char key;
int num_scanned;
/* initialize connection to IPC network */
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
/* open logfile, check if file overwrites something */
if(argc < 2)
carmen_die("usage: %s <logfile>\n", argv[0]);
sprintf(filename, "%s", argv[1]);
outfile = carmen_fopen(filename, "r");
if (outfile != NULL) {
fprintf(stderr, "Overwrite %s? ", filename);
num_scanned = scanf("%c", &key);
if (toupper(key) != 'Y')
exit(-1);
carmen_fclose(outfile);
}
outfile = carmen_fopen(filename, "w");
if(outfile == NULL)
carmen_die("Error: Could not open file %s for writing.\n", filename);
carmen_logwrite_write_header(outfile);
get_logger_params(argc, argv);
if ( !(log_odometry && log_laser && log_robot_laser ) )
carmen_warn("\nWARNING: You are neither logging laser nor odometry messages!\n");
if (log_params)
get_all_params();
register_ipc_messages();
if (log_odometry)
carmen_base_subscribe_odometry_message(NULL, (carmen_handler_t)
base_odometry_handler,
CARMEN_SUBSCRIBE_ALL);
if (log_sonars)
carmen_base_subscribe_sonar_message(NULL, (carmen_handler_t)
base_sonar_handler,
CARMEN_SUBSCRIBE_ALL);
if (log_bumpers)
carmen_base_subscribe_bumper_message(NULL, (carmen_handler_t)
base_bumper_handler,
CARMEN_SUBSCRIBE_ALL);
if (log_arm)
carmen_arm_subscribe_state_message(NULL, (carmen_handler_t)
arm_state_handler,
CARMEN_SUBSCRIBE_ALL);
if (log_pantilt) {
carmen_pantilt_subscribe_scanmark_message (NULL, (carmen_handler_t)
pantilt_scanmark_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_pantilt_subscribe_laserpos_message (NULL, (carmen_handler_t)
pantilt_laserpos_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_robot_laser) {
carmen_robot_subscribe_frontlaser_message(NULL, (carmen_handler_t)
robot_frontlaser_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_robot_subscribe_rearlaser_message(NULL, (carmen_handler_t)
robot_rearlaser_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_laser) {
carmen_laser_subscribe_laser1_message(NULL, (carmen_handler_t)
laser_laser1_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_laser_subscribe_laser2_message(NULL, (carmen_handler_t)
laser_laser2_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_laser_subscribe_laser3_message(NULL, (carmen_handler_t)
laser_laser3_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_laser_subscribe_laser4_message(NULL, (carmen_handler_t)
laser_laser4_handler,
CARMEN_SUBSCRIBE_ALL);
carmen_laser_subscribe_laser5_message(NULL, (carmen_handler_t)
laser_laser5_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_localize) {
carmen_localize_subscribe_globalpos_message(NULL, (carmen_handler_t)
localize_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_simulator) {
carmen_simulator_subscribe_truepos_message(NULL, (carmen_handler_t)
carmen_simulator_truepos_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_imu) {
carmen_imu_subscribe_imu_message(NULL, (carmen_handler_t)
imu_handler,
CARMEN_SUBSCRIBE_ALL);
}
if (log_gps) {
carmen_gps_subscribe_nmea_message( NULL,
(carmen_handler_t) ipc_gps_gpgga_handler,
CARMEN_SUBSCRIBE_ALL );
carmen_gps_subscribe_nmea_rmc_message( NULL,
(carmen_handler_t) ipc_gps_gprmc_handler,
CARMEN_SUBSCRIBE_ALL );
}
if (log_motioncmds) {
carmen_robot_subscribe_vector_move_message( NULL,
(carmen_handler_t) robot_vector_move_handler,
CARMEN_SUBSCRIBE_ALL );
carmen_robot_subscribe_follow_trajectory_message( NULL,
(carmen_handler_t) robot_follow_trajectory_handler,
CARMEN_SUBSCRIBE_ALL );
carmen_robot_subscribe_velocity_message( NULL,
(carmen_handler_t) robot_velocity_handler,
CARMEN_SUBSCRIBE_ALL );
carmen_base_subscribe_velocity_message( NULL,
(carmen_handler_t) base_velocity_handler,
CARMEN_SUBSCRIBE_ALL );
}
carmen_logger_subscribe_comment_message( NULL,
(carmen_handler_t) logger_comment_handler,
CARMEN_SUBSCRIBE_ALL );
signal(SIGINT, shutdown_module);
logger_starttime = carmen_get_time();
carmen_ipc_dispatch();
return 0;
}
void Carmen_Thread::run() {
carmen_ipc_dispatch();
}
