int main(int argc, char *argv[])
{
unsigned int seed;
carmen_initialize_ipc(argv[0]);
carmen_param_check_version(argv[0]);
IPC_setVerbosity(IPC_Print_Warnings);
seed = carmen_randomize(&argc, &argv);
carmen_warn("Seed: %u\n", seed);
carmen_simulator_subscribe_truepos_message
(&truepose, NULL, CARMEN_SUBSCRIBE_LATEST);
carmen_simulator_subscribe_objects_message
(NULL, (carmen_handler_t)simulator_objects_handler,
CARMEN_SUBSCRIBE_LATEST);
map = (carmen_map_t *)calloc(1, sizeof(carmen_map_t));
carmen_test_alloc(map);
carmen_map_get_gridmap(map);
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[])
{
a = new QApplication(argc, argv);
w = new skeleton_module_view();
/* 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);
/* Register Carmen Callbacks to Qt interface */
carmen_graphics_update_ipc_callbacks_qt(w, SLOT(updateIPC(int)));
/* Define published messages by your module */
carmen_skeleton_module_filter_define_messages();
/* Subscribe to sensor messages */
carmen_skeleton_module_filter_subscribe_upkeymessage(NULL, (carmen_handler_t) upkeymessage_handler, CARMEN_SUBSCRIBE_LATEST);
w->show();
return a->exec();
}
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) {
int guidance_config;
carmen_initialize_ipc(argv[0]);
carmen_param_check_version(argv[0]);
if (argc < 3)
carmen_die("usage: imp_goto <guidance config> <goal name>\n"
"guidance config:\n"
" baseline"
" arrow"
" text_ai"
" text_woz"
" audio"
" audio_arrow"
" audio_text_ai"
" audio_text_woz\n");
guidance_config = SQUEEZE_HANDLES_DELAY;
if (strstr(argv[1], "arrow"))
guidance_config |= ARROW_GUIDANCE;
else if (strstr(argv[1], "text"))
guidance_config |= TEXT_GUIDANCE;
if (strstr(argv[1], "audio"))
guidance_config |= AUDIO_GUIDANCE;
if (strstr(argv[1], "woz"))
guidance_config |= WOZ_GUIDANCE;
carmen_walker_guidance_config(guidance_config);
carmen_walker_guidance_goto(argv[2]);
return 0;
}
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)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
#ifndef COMPILE_WITHOUT_LASER_SUPPORT
carmen_robot_subscribe_frontlaser_message
(NULL, (carmen_handler_t)robot_frontlaser_handler,
CARMEN_SUBSCRIBE_LATEST);
carmen_robot_subscribe_rearlaser_message
(NULL,(carmen_handler_t)robot_rearlaser_handler,
CARMEN_SUBSCRIBE_LATEST);
#endif
carmen_robot_subscribe_sonar_message
(NULL, (carmen_handler_t)robot_sonar_handler,
CARMEN_SUBSCRIBE_LATEST);
carmen_base_subscribe_odometry_message
(NULL, (carmen_handler_t)base_odometry_handler,
CARMEN_SUBSCRIBE_LATEST);
carmen_robot_move_along_vector(0, M_PI/2);
sleep(10);
carmen_robot_move_along_vector(2, 0);
while(1) {
carmen_ipc_sleep(0.1);
carmen_warn(".");
}
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)
{
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]);
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[])
{
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) {
int c;
carmen_ipc_initialize(argc,argv);
carmen_param_check_version(argv[0]);
signal(SIGINT, shutdown_module);
if (argc > 1 && !strcmp(argv[1], "-sim"))
simulation = 1;
if (carmen_map_get_hmap(&hmap) < 0)
carmen_die("no hmap found\n");
print_hmap(); //dbug
carmen_map_change_map_zone(hmap.zone_names[0]); //dbug: this should go in the map server
map_zone = 0;
ipc_init();
carmen_terminal_cbreak(0);
while(1) {
carmen_ipc_sleep(0.01);
c = getchar();
/*
if (c == EOF)
break;
*/
if (c != 27)
continue;
c = getchar();
/*
if (c == EOF)
break;
*/
if (c != 91)
continue;
c = getchar();
/*
if (c == EOF)
break;
*/
switch(c) {
case 65: level_up(); break;
case 66: level_down();
}
}
return 0;
}
Carmen_Thread::Carmen_Thread(int argc, char **argv) {
this->argc = argc;
this->argv = argv;
if(singleton == NULL) {
singleton = this;
}
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
read_parameters(argc, argv);
declare_messages();
register_meta_types();
}
int
main(int argc, char **argv)
{
int i=atoi(argv[1]);
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
fprintf(stderr, "dumping laser %d\n", i);
static carmen_laser_laser_message laser;
carmen_laser_subscribe_laser_message(i,&laser, (carmen_handler_t)
laser_handler,
CARMEN_SUBSCRIBE_LATEST);
while(1) IPC_listen(10);
return 0;
}
void carmen_multicentral_get_params(carmen_centrallist_p centrallist,
int argc, char **argv,
void (*param_func)(int, char **))
{
int i;
/* get parameters from first valid central */
for(i = 0; i < centrallist->num_centrals; i++)
if(centrallist->central[i].connected) {
IPC_setContext(centrallist->central[i].context);
carmen_param_check_version(argv[0]);
param_func(argc, argv);
break;
}
}
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_initialize_ipc(argv[0]);
carmen_param_check_version(argv[0]);
if (carmen_cerebellum_start(argc, argv) < 0)
exit(-1);
signal(SIGINT, shutdown_cerebellum);
while(1) {
sleep_ipc(0.01);
carmen_cerebellum_run();
}
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)
{
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)
{
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
carmen_robot_ackerman_start(argc, argv);
signal(SIGINT, shutdown_robot_ackerman);
while (1)
{
carmen_ipc_sleep(0.1);
carmen_robot_ackerman_run();
}
return 0;
}
int main(int argc, char **argv)
{
double command_tv = 0.0, command_rv = 0.0;
char c;
int quit = 0;
double f_timestamp;
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
// Initialize keybord, joystick and IPC
carmen_initialize_keyboard();
if (carmen_initialize_joystick(&joystick) >= 0)
no_joystick = 0;
read_parameters(argc, argv);
signal(SIGINT, sig_handler);
f_timestamp = carmen_get_time();
while(quit>=0) {
carmen_ipc_sleep(0.05);
if(!no_joystick && carmen_get_joystick_state(&joystick) >= 0) {
carmen_joystick_control(&joystick, max_tv, max_rv,
&command_tv, &command_rv);
carmen_robot_velocity_command(command_tv, command_rv);
f_timestamp = carmen_get_time();
}
else if(carmen_read_char(&c)) {
quit = carmen_keyboard_control(c, max_tv, max_rv,
&command_tv, &command_rv);
carmen_robot_velocity_command(command_tv, command_rv);
f_timestamp = carmen_get_time();
}
else if(carmen_get_time() - f_timestamp > 0.5) {
carmen_robot_velocity_command(command_tv, command_rv);
f_timestamp = carmen_get_time();
}
}
sig_handler(SIGINT);
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)
{
carmen_camera_image_t *image;
IPC_RETURN_TYPE err;
double interframe_sleep = 5.0;
int param_err;
/* connect to IPC server */
carmen_ipc_initialize(argc, argv);
carmen_param_check_version(argv[0]);
err = IPC_defineMsg(CARMEN_CAMERA_IMAGE_NAME, IPC_VARIABLE_LENGTH,
CARMEN_CAMERA_IMAGE_FMT);
carmen_test_ipc_exit(err, "Could not define", CARMEN_CAMERA_IMAGE_NAME);
carmen_param_allow_unfound_variables(0);
param_err = carmen_param_get_double("camera_interframe_sleep", &interframe_sleep, NULL);
if (param_err < 0)
carmen_die("Could not find parameter in carmen.ini file: camera_interframe_sleep\n");
image = carmen_camera_start(argc, argv);
if (image == NULL)
exit(-1);
signal(SIGINT, shutdown_module);
while(1) {
carmen_camera_grab_image(image);
if(image->is_new) {
carmen_camera_publish_image_message(image);
carmen_warn("c");
image->is_new = 0;
}
// We are rate-controlling the camera.
carmen_publish_heartbeat("camera_daemon");
carmen_ipc_sleep(interframe_sleep);
}
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;
}
