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