void Carmen_Thread::declare_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_BASE_ACKERMAN_VELOCITY_NAME, IPC_VARIABLE_LENGTH, CARMEN_BASE_ACKERMAN_VELOCITY_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_BASE_ACKERMAN_VELOCITY_NAME); err = IPC_defineMsg(CARMEN_LOCALIZE_ACKERMAN_SENSOR_NAME, IPC_VARIABLE_LENGTH, CARMEN_LOCALIZE_ACKERMAN_SENSOR_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_LOCALIZE_ACKERMAN_SENSOR_NAME); err = IPC_defineMsg(CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME, IPC_VARIABLE_LENGTH, CARMEN_NAVIGATOR_ACKERMAN_PLAN_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME); carmen_laser_define_laser_message(1); carmen_grid_mapping_define_messages(); carmen_rrt_planner_define_robot_tree_message(); carmen_rrt_planner_define_status_message(); }
int main (void) #endif { int j; float *data; #ifdef VXWORKS { int currentPriority; /* The producer needs to run at a lower priority, else it swamps central and the consumer */ taskPriorityGet(taskIdSelf(), ¤tPriority); taskPrioritySet(taskIdSelf(), currentPriority+10); } #endif data = (float *)malloc(MAX_DATA_SIZE); for (j = 0; j<MAX_DATA_SIZE/sizeof(float); j++) data[j] = (float) j; IPC_connect("sender"); IPC_defineMsg(NULL_MSG, 0, NULL); IPC_defineMsg(FLOAT4_MSG, sizeof(float)*4, NULL); IPC_defineMsg(FLOAT16_MSG, sizeof(float)*16, NULL); IPC_defineMsg(FLOAT64_MSG, sizeof(float)*64, NULL); IPC_defineMsg(FLOAT256_MSG, sizeof(float)*256, NULL); IPC_defineMsg(FLOAT1K_MSG, sizeof(float)*1024, NULL); IPC_defineMsg(FLOAT4K_MSG, sizeof(float)*4*1024, NULL); IPC_defineMsg(FLOAT16K_MSG, sizeof(float)*16*1024, NULL); IPC_defineMsg(FLOAT64K_MSG, sizeof(float)*64*1024, NULL); IPC_defineMsg(FLOAT256K_MSG, sizeof(float)*256*1024, NULL); IPC_subscribe(DONE_MSG, doneHandler, NULL); sendMessages(NULL_MSG, 0, data); sendMessages(FLOAT4_MSG, sizeof(float)*4, data); sendMessages(FLOAT16_MSG, sizeof(float)*16, data); sendMessages(FLOAT64_MSG, sizeof(float)*64, data); sendMessages(FLOAT256_MSG, sizeof(float)*256, data); sendMessages(FLOAT1K_MSG, sizeof(float)*1024, data); sendMessages(FLOAT4K_MSG, sizeof(float)*4*1024, data); sendMessages(FLOAT16K_MSG, sizeof(float)*16*1024, data); sendMessages(FLOAT64K_MSG, sizeof(float)*64*1024, data); sendMessages(FLOAT256K_MSG, sizeof(float)*256*1024, data); /* Wait for everything to settle down before shutting down */ sleep(2); /* shut down */ printf ("\n"); fflush(stdout); IPC_disconnect(); #if !defined(VXWORKS) return 0; #endif }
void carmen_parking_assistant_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_PARKING_ASSISTANT_GOAL_NAME, IPC_VARIABLE_LENGTH, CARMEN_PARKING_ASSISTANT_GOAL_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_PARKING_ASSISTANT_GOAL_NAME); err = IPC_defineMsg(CARMEN_PARKING_ASSISTANT_PARKING_SPACE_NAME, IPC_VARIABLE_LENGTH, CARMEN_PARKING_ASSISTANT_PARKING_SPACE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_PARKING_ASSISTANT_PARKING_SPACE_NAME); }
void carmen_mapper_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_MAPPER_MAP_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_MAPPER_MAP_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_MAPPER_MAP_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_MAPPER_MAP_MOVING_OBJECTS_RAW_MAP_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_MAPPER_MAP_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_MAPPER_MAP_MOVING_OBJECTS_RAW_MAP_MESSAGE_NAME); }
void carmen_localize_initialize_uniform_command(void) { static carmen_localize_initialize_message init; static int first = 1; IPC_RETURN_TYPE err; if(first) { err = IPC_defineMsg(CARMEN_LOCALIZE_INITIALIZE_NAME, IPC_VARIABLE_LENGTH, CARMEN_LOCALIZE_INITIALIZE_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_LOCALIZE_INITIALIZE_NAME); first = 0; } init.timestamp = carmen_get_time(); init.host = carmen_get_host(); init.distribution = CARMEN_INITIALIZE_UNIFORM; init.num_modes = 0; init.mean = NULL; init.std = NULL; err = IPC_publishData(CARMEN_LOCALIZE_INITIALIZE_NAME, &init); carmen_test_ipc(err, "Could not publish", CARMEN_LOCALIZE_INITIALIZE_NAME); }
int carmen_navigator_query_status(carmen_navigator_status_message **status_msg) { IPC_RETURN_TYPE err; carmen_navigator_status_query_message *msg; static int initialized = 0; msg = carmen_default_message_create(); if (!initialized) { err = IPC_defineMsg(CARMEN_NAVIGATOR_STATUS_QUERY_NAME, IPC_VARIABLE_LENGTH, CARMEN_DEFAULT_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_NAVIGATOR_STATUS_QUERY_NAME); initialized = 1; } err = IPC_queryResponseData(CARMEN_NAVIGATOR_STATUS_QUERY_NAME, msg, (void **)status_msg, timeout); carmen_test_ipc_return_int(err, "Could not query navigator status", CARMEN_NAVIGATOR_STATUS_QUERY_NAME); return 0; }
void carmen_robot_follow_trajectory(carmen_traj_point_t *trajectory, int trajectory_length, carmen_traj_point_t *robot) { IPC_RETURN_TYPE err; static carmen_robot_follow_trajectory_message msg; err = IPC_defineMsg(CARMEN_ROBOT_FOLLOW_TRAJECTORY_NAME, IPC_VARIABLE_LENGTH, CARMEN_ROBOT_FOLLOW_TRAJECTORY_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_ROBOT_FOLLOW_TRAJECTORY_NAME); msg.trajectory = trajectory; msg.trajectory_length = trajectory_length; msg.robot_position = *robot; msg.timestamp = carmen_get_time(); msg.host = carmen_get_host(); err = IPC_publishData(CARMEN_ROBOT_FOLLOW_TRAJECTORY_NAME, &msg); carmen_test_ipc(err, "Could not publish", CARMEN_ROBOT_FOLLOW_TRAJECTORY_NAME); }
void carmen_grid_mapping_publish_distance_map_message(carmen_grid_mapping_distance_map *distance_map, double timestamp) { IPC_RETURN_TYPE err; static carmen_grid_mapping_distance_map_message distance_map_message; static int first_time = 1; if (first_time) { err = IPC_defineMsg(CARMEN_GRID_MAPPING_DISTANCE_MAP_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_GRID_MAPPING_DISTANCE_MAP_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_GRID_MAPPING_DISTANCE_MAP_MESSAGE_NAME); first_time = 0; } distance_map_message.config = distance_map->config; strcpy(distance_map_message.config.origin, "from_mapping"); distance_map_message.size = distance_map->config.x_size * distance_map->config.y_size; distance_map_message.complete_x_offset = distance_map->complete_x_offset; distance_map_message.complete_y_offset = distance_map->complete_y_offset; distance_map_message.timestamp = timestamp; distance_map_message.host = carmen_get_host(); err = IPC_publishData(CARMEN_GRID_MAPPING_DISTANCE_MAP_MESSAGE_NAME, &distance_map_message); carmen_test_ipc_exit(err, "Could not publish", CARMEN_GRID_MAPPING_DISTANCE_MAP_MESSAGE_NAME); }
static void carmen_motion_planner_publish_path_message( carmen_ackerman_traj_point_t *path, int size, int algorithm) { IPC_RETURN_TYPE err; static int firsttime = 1; static carmen_motion_planner_path_message msg; if(firsttime) { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_MOTION_PLANNER_PATH_NAME, IPC_VARIABLE_LENGTH, CARMEN_MOTION_PLANNER_PATH_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_MOTION_PLANNER_PATH_NAME); msg.host = carmen_get_host(); firsttime = 0; } msg.timestamp = carmen_get_time(); msg.path = path; msg.path_size = size; msg.algorithm = algorithm; err = IPC_publishData(CARMEN_MOTION_PLANNER_PATH_NAME, &msg); carmen_test_ipc(err, "Could not publish", CARMEN_MOTION_PLANNER_PATH_NAME); }
void publish_navigator_ackerman_plan_message(carmen_ackerman_traj_point_t *points_vector, int size) { carmen_navigator_ackerman_plan_message msg; static int first_time = 1; IPC_RETURN_TYPE err; msg.path = points_vector; msg.path_length = size; msg.host = carmen_get_host(); msg.timestamp = carmen_get_time(); if (first_time) { err = IPC_defineMsg(CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME, IPC_VARIABLE_LENGTH, CARMEN_NAVIGATOR_ACKERMAN_PLAN_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME); first_time = 0; } err = IPC_publishData(CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME, &msg); carmen_test_ipc(err, "Could not publish", CARMEN_NAVIGATOR_ACKERMAN_PLAN_NAME); }
static void publish_spline_goal_message(carmen_ackerman_traj_point_t poses) { IPC_RETURN_TYPE err; carmen_navigator_ackerman_set_goal_message goal_msg; static int initialized = 0; if (!initialized) { err = IPC_defineMsg(CARMEN_NAVIGATOR_ACKERMAN_SET_GOAL_NAME, IPC_VARIABLE_LENGTH, CARMEN_NAVIGATOR_ACKERMAN_SET_GOAL_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_NAVIGATOR_ACKERMAN_SET_GOAL_NAME); initialized = 1; } goal_msg.x = poses.x; goal_msg.y = poses.y; goal_msg.theta = globalpos.theta; goal_msg.host = carmen_get_host(); goal_msg.timestamp = carmen_get_time(); err = IPC_publishData(CARMEN_NAVIGATOR_ACKERMAN_SET_GOAL_NAME, &goal_msg); carmen_test_ipc_exit(err, "Could not publish", CARMEN_NAVIGATOR_ACKERMAN_SET_GOAL_NAME); }
void carmen_velodyne_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_VELODYNE_PARTIAL_SCAN_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_VELODYNE_PARTIAL_SCAN_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_VELODYNE_PARTIAL_SCAN_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_VELODYNE_GPS_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_VELODYNE_GPS_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_VELODYNE_GPS_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_VELODYNE_VARIABLE_SCAN_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_VELODYNE_VARIABLE_SCAN_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_VELODYNE_VARIABLE_SCAN_MESSAGE_NAME); }
int carmen_navigator_set_goal_triplet(carmen_point_p goal) { IPC_RETURN_TYPE err = IPC_OK; carmen_navigator_set_goal_triplet_message msg; static int initialized = 0; if (!initialized) { err = IPC_defineMsg(CARMEN_NAVIGATOR_SET_GOAL_TRIPLET_NAME, IPC_VARIABLE_LENGTH, CARMEN_NAVIGATOR_SET_GOAL_TRIPLET_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_NAVIGATOR_SET_GOAL_TRIPLET_NAME); initialized = 1; } msg.goal = *goal; msg.timestamp = carmen_get_time(); msg.host = carmen_get_host(); err = IPC_publishData(CARMEN_NAVIGATOR_SET_GOAL_TRIPLET_NAME, &msg); carmen_test_ipc(err, "Could not publish", CARMEN_NAVIGATOR_SET_GOAL_TRIPLET_NAME); return 0; }
static void subject_publish_callback(const ViconDriver::Subject &subject) { static std::set<std::string> defined_msgs; std::string msgname = "vicon_" + subject.name; if(defined_msgs.find(msgname) == defined_msgs.end()) { if(pthread_mutex_trylock(&ipc_mutex) == 0) { IPC_defineMsg(msgname.c_str(), IPC_VARIABLE_LENGTH, ViconSubject::getIPCFormat()); pthread_mutex_unlock(&ipc_mutex); defined_msgs.insert(msgname); } else return; } if(loadCalib(subject.name)) { Eigen::Affine3d current_pose = Eigen::Affine3d::Identity(); current_pose.translate(Eigen::Vector3d(subject.translation)); current_pose.rotate(Eigen::Quaterniond(subject.rotation)); current_pose = current_pose*calib_pose[subject.name]; const Eigen::Vector3d position(current_pose.translation()); const Eigen::Quaterniond rotation(current_pose.rotation()); ViconSubject subject_ipc; subject_ipc.time_sec = subject.time_usec/1000000; // Integer division subject_ipc.time_usec = subject.time_usec - subject_ipc.time_sec*1000000; subject_ipc.frame_number = subject.frame_number; subject_ipc.name = const_cast<char*>(subject.name.c_str()); subject_ipc.occluded = subject.occluded; subject_ipc.position[0] = position.x(); subject_ipc.position[1] = position.y(); subject_ipc.position[2] = position.z(); subject_ipc.orientation[0] = rotation.x(); subject_ipc.orientation[1] = rotation.y(); subject_ipc.orientation[2] = rotation.z(); subject_ipc.orientation[3] = rotation.w(); subject_ipc.num_markers = subject.markers.size(); subject_ipc.markers = new ViconMarker[subject_ipc.num_markers]; for(int i = 0; i < subject_ipc.num_markers; i++) { subject_ipc.markers[i].name = const_cast<char*>(subject.markers[i].name.c_str()); subject_ipc.markers[i].subject_name = const_cast<char*>(subject.markers[i].subject_name.c_str()); subject_ipc.markers[i].position[0] = subject.markers[i].translation[0]; subject_ipc.markers[i].position[1] = subject.markers[i].translation[1]; subject_ipc.markers[i].position[2] = subject.markers[i].translation[2]; subject_ipc.markers[i].occluded = subject.markers[i].occluded; } if(pthread_mutex_trylock(&ipc_mutex) == 0) { IPC_publishData(msgname.c_str(), &subject_ipc); pthread_mutex_unlock(&ipc_mutex); } delete[] subject_ipc.markers; } }
void carmen_localize_initialize_gaussian_command(carmen_point_t mean, carmen_point_t std) { static carmen_localize_initialize_message init; static int first = 1; IPC_RETURN_TYPE err; if(first) { err = IPC_defineMsg(CARMEN_LOCALIZE_INITIALIZE_NAME, IPC_VARIABLE_LENGTH, CARMEN_LOCALIZE_INITIALIZE_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_LOCALIZE_INITIALIZE_NAME); first = 0; } init.timestamp = carmen_get_time(); init.host = carmen_get_host(); init.distribution = CARMEN_INITIALIZE_GAUSSIAN; init.num_modes = 1; init.mean = &mean; init.std = &std; err = IPC_publishData(CARMEN_LOCALIZE_INITIALIZE_NAME, &init); carmen_test_ipc(err, "Could not publish", CARMEN_LOCALIZE_INITIALIZE_NAME); }
void carmen_minoru_define_bumblebee_fake_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_BUMBLEBEE_BASIC_STEREOIMAGE10_NAME, IPC_VARIABLE_LENGTH, CARMEN_BUMBLEBEE_BASIC_STEREOIMAGE10_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_BUMBLEBEE_BASIC_STEREOIMAGE10_NAME); }
void carmen_minoru_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_MINORU_STEREOIMAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_MINORU_STEREOIMAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_MINORU_STEREOIMAGE_NAME); }
void carmen_navigator_spline_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_NAVIGATOR_SPLINE_PATH_NAME, IPC_VARIABLE_LENGTH, CARMEN_NAVIGATOR_SPLINE_PATH_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_NAVIGATOR_SPLINE_PATH_NAME); }
void carmen_fast_polar_slam_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_FAST_POLAR_SLAM_BEST_PARTICLE_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_FAST_POLAR_SLAM_BEST_PARTICLE_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_FAST_POLAR_SLAM_BEST_PARTICLE_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_FAST_POLAR_SLAM_VELODYNE_PROJECTED_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_FAST_POLAR_SLAM_VELODYNE_PROJECTED_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_FAST_POLAR_SLAM_VELODYNE_PROJECTED_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_FAST_POLAR_SLAM_PARTICLES_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_FAST_POLAR_SLAM_PARTICLES_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_FAST_POLAR_SLAM_PARTICLES_MESSAGE_NAME); err = IPC_defineMsg(CARMEN_FAST_POLAR_SLAM_MEASUREMENT_MODEL_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_FAST_POLAR_SLAM_MEASUREMENT_MODEL_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_FAST_POLAR_SLAM_MEASUREMENT_MODEL_MESSAGE_NAME); }
IPC_RETURN_TYPE carmen_visual_tracker_define_message_train(void) { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_VISUAL_TRACKER_TRAIN_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_VISUAL_TRACKER_TRAIN_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_VISUAL_TRACKER_TRAIN_MESSAGE_NAME); return(err); }
void carmen_joystick_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_JOYSTICK_STATUS_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_JOYSTICK_STATUS_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_JOYSTICK_STATUS_MESSAGE_NAME); }
void carmen_monte_carlo_localization_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_MONTE_CARLO_LOCALIZATION_NAME, IPC_VARIABLE_LENGTH, CARMEN_MONTE_CARLO_LOCALIZATION_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_MONTE_CARLO_LOCALIZATION_NAME); }
void carmen_slam6d_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_SLAM6D_POINTCLOUD_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_SLAM6D_POINTCLOUD_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_SLAM6D_POINTCLOUD_MESSAGE_NAME); }
void carmen_saliency_define_saliency_points_message() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_SALIENCY_SEARCH_SALIENCY_POINTS_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_SALIENCY_SEARCH_SALIENCY_POINTS_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_SALIENCY_SEARCH_SALIENCY_POINTS_MESSAGE_NAME); }
void carmen_landmark_localization_define_messages() { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_LANDMARK_LOCALIZATION_STATE_MESSAGE_NAME, IPC_VARIABLE_LENGTH, CARMEN_LANDMARK_LOCALIZATION_STATE_MESSAGE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_LANDMARK_LOCALIZATION_STATE_MESSAGE_NAME); }
/** Defines IPC types declared in command_ipc.h and in SVM_VisionModule.h */ int define_command_ipc_types(void) { printf("Defining IPC darwin-command types and messages.\n"); // SVM_VisionModule IPC commands // // set the mode by sending an SVM_Mode variable if( !IPC_isMsgDefined(SVM_MODE) ){ printf("defining svm_mode\n"); IPC_defineMsg(SVM_MODE, IPC_VARIABLE_LENGTH, SVM_Mode_FORMAT); } // set an operator's state (on/off/PTZ attributes) by sending an operator command if( !IPC_isMsgDefined(SVM_COMMAND) ){ printf("defining svm_command\n"); IPC_defineMsg(SVM_COMMAND, IPC_VARIABLE_LENGTH, SVM_Operator_Command_FORMAT); } // request data from a specific operator by sending an SVM_Operator variable if( !IPC_isMsgDefined(SVM_DATA_REQUEST) ) IPC_defineMsg(SVM_DATA_REQUEST, IPC_VARIABLE_LENGTH, SVM_Operator_FORMAT); // receive data from a specific operator if( !IPC_isMsgDefined(SVM_DATA_RESPONSE) ) IPC_defineMsg(SVM_DATA_RESPONSE, IPC_VARIABLE_LENGTH, SVM_Operator_Data_FORMAT); // send acks from specific operators if( !IPC_isMsgDefined(SVM_ACK) ) IPC_defineMsg(SVM_ACK, IPC_VARIABLE_LENGTH, SVM_Ack_FORMAT); // IPC message for sending world locations if(!IPC_isMsgDefined(SVM_LOCATION)) IPC_defineMsg(SVM_LOCATION, IPC_VARIABLE_LENGTH, SVM_Location_FORMAT); // IPC message for sending world locations if(!IPC_isMsgDefined(SVM_LOOK_AT)) IPC_defineMsg(SVM_LOOK_AT, IPC_VARIABLE_LENGTH, SVM_Location_FORMAT); if(!IPC_isMsgDefined(SVM_AE_SETTING)) IPC_defineMsg(SVM_AE_SETTING, IPC_VARIABLE_LENGTH, SVM_AE_Setting_FORMAT); if(!IPC_isMsgDefined(SVM_AE_QUERY)) IPC_defineMsg(SVM_AE_QUERY, IPC_VARIABLE_LENGTH, SVM_AE_Setting_FORMAT); if(!IPC_isMsgDefined(SVM_AE_RESPONSE)) IPC_defineMsg(SVM_AE_RESPONSE, IPC_VARIABLE_LENGTH, SVM_AE_Setting_FORMAT); }
void define_messages() { IPC_RETURN_TYPE err; carmen_localize_ackerman_define_globalpos_messages(); err = IPC_defineMsg(CARMEN_FUSED_ODOMETRY_PARTICLE_NAME, IPC_VARIABLE_LENGTH, CARMEN_FUSED_ODOMETRY_PARTICLE_FMT); carmen_test_ipc_exit(err, "Could not define", CARMEN_FUSED_ODOMETRY_PARTICLE_NAME); }
static int initialize_ipc(void) { IPC_RETURN_TYPE err; err = IPC_defineMsg(CARMEN_BASE_ACKERMAN_ODOMETRY_NAME, IPC_VARIABLE_LENGTH, CARMEN_BASE_ACKERMAN_ODOMETRY_FMT); carmen_test_ipc_exit(err, "Could not define message", CARMEN_BASE_ACKERMAN_ODOMETRY_NAME); return 0; }
IPC_RETURN_TYPE carmen_stereo_mapping_define_messages(int camera) { IPC_RETURN_TYPE err; char *stereo_mapping_msg_name = carmen_stereo_mapping_get_messagename(camera); err = IPC_defineMsg(stereo_mapping_msg_name, IPC_VARIABLE_LENGTH, CARMEN_STEREO_MAPPING_FMT); carmen_test_ipc_exit(err, "Could not define", stereo_mapping_msg_name); return err; }
IPC_RETURN_TYPE carmen_bumblebee_basic_define_messages(int camera) { IPC_RETURN_TYPE err; char *message_name = carmen_bumblebee_basic_message_name(camera); err = IPC_defineMsg(message_name, IPC_VARIABLE_LENGTH, CARMEN_BUMBLEBEE_BASIC_STEREOIMAGE_FMT); carmen_test_ipc_exit(err, "Could not define", message_name); free(message_name); return err; }