Gazebo

Frontpage

Contents

User

Installation

User Guide

Reference Guide

Class List

Class Hierarchy

Console-mode Server

Interactive Server

Working with Player

Worldfile Syntax

Using libgazebo

ToDo list

Online

Homepage

Download

Project

Bugs

Help

gazebo.h

Go to the documentation of this file.

/*
 *  Gazebo - Outdoor Multi-Robot Simulator
 *  Copyright (C) 2003  
 *     Nate Koenig & Andrew Howard
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/* Desc: External interfaces for Gazebo
 * Author: Andrew Howard
 * Date: 6 Apr 2003
 * CVS: $Id: gazebo.h,v 1.87 2006/11/02 17:06:31 natepak Exp $
 */

#ifndef GAZEBO_H
#define GAZEBO_H

#include <sys/types.h>
#include <stdlib.h>
#include <stdint.h>


#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************
 * Constants, etc
 **************************************************************************/


#define LIBGAZEBO_VERSION 0x060

    
/***************************************************************************/

/***************************************************************************/

void gz_error_init(int print, int level);
  
const char *gz_error_str(void);


/***************************************************************************/


/***************************************************************************/


typedef struct gz_server
{
  int server_id;

  char *filename;

  int sem_key, sem_cid;
    
} gz_server_t;


extern gz_server_t *gz_server_alloc();

extern void gz_server_free(gz_server_t *self);

extern int gz_server_init(gz_server_t *self, int server_id, int force);

extern int gz_server_fini(gz_server_t *self);

extern int gz_server_post(gz_server_t *self);


/***************************************************************************/

  
/***************************************************************************/


#define GZ_SEM_KEY 0x135135FA
  
#define GZ_CLIENT_ID_USER_FIRST 0x00
#define GZ_CLIENT_ID_USER_LAST  0x07
#define GZ_CLIENT_ID_WXGAZEBO   0x08
#define GZ_CLIENT_ID_PLAYER     0x09

  
typedef struct gz_client
{
  int server_id;

  int client_id;

  char *filename;

  int sem_key, sem_cid;

} gz_client_t;


extern gz_client_t *gz_client_alloc();

extern void gz_client_free(gz_client_t *self);

extern int gz_client_query(gz_client_t *self, int server_id);

extern int gz_client_connect(gz_client_t *self, int server_id);

extern int gz_client_connect_wait(gz_client_t *self, int server_id, int client_id);

extern int gz_client_disconnect(gz_client_t *self);

extern int gz_client_wait(gz_client_t *self);




/***************************************************************************/


#define GAZEBO_MAX_MODEL_TYPE 128

typedef struct gz_data
{
  int version;

  size_t size;

  char model_type[GAZEBO_MAX_MODEL_TYPE];
  
  int model_id;

  int parent_model_id;
  
} gz_data_t;





/***************************************************************************/

typedef struct gz_iface
{
  // The server we are associated with
  gz_server_t *server;
  
  // The client we are associated with
  gz_client_t *client;
  
  // File descriptor for the mmap file
  int mmap_fd;

  // Pointer to the mmap'ed mem
  void *mmap;

  // The name of the file we created/opened
  char *filename;
  
} gz_iface_t;


// Create an interface
extern gz_iface_t *gz_iface_alloc();

// @internal Destroy an interface
extern void gz_iface_free(gz_iface_t *self);

// @internal Create the interface (used by Gazebo server)
extern int gz_iface_create(gz_iface_t *self, gz_server_t *server,
                           const char *type, const char *id, size_t size);

// @internal Destroy the interface (server)
extern int gz_iface_destroy(gz_iface_t *self);

// Open an existing interface
extern int gz_iface_open(gz_iface_t *self, gz_client_t *client,
                         const char *type, const char *id, size_t size);

// Close the interface
extern int gz_iface_close(gz_iface_t *self);

// Lock the interface.  Set blocking to 1 if the caller should block
// until the lock is acquired.  Returns 0 if the lock is acquired.
extern int gz_iface_lock(gz_iface_t *self, int blocking);

// Unlock the interface
extern void gz_iface_unlock(gz_iface_t *self);

// Tell clients that new data is available
extern int gz_iface_post(gz_iface_t *self);





/***************************************************************************/


typedef struct gz_sim_data
{
  gz_data_t head;
  
  double sim_time;

  double pause_time;

  // Elapsed real time since start of simulation (from system clock). 
  double real_time;

  int pause;

  int reset;

  int save;

} gz_sim_data_t;


typedef struct gz_sim
{
  gz_iface_t *iface;

  gz_sim_data_t *data;

} gz_sim_t;


extern gz_sim_t *gz_sim_alloc();

extern void gz_sim_free(gz_sim_t *self);

extern int gz_sim_create(gz_sim_t *self, gz_server_t *server, const char *id);

extern int gz_sim_destroy(gz_sim_t *self);

extern int gz_sim_open(gz_sim_t *self, gz_client_t *client, const char *id);

extern int gz_sim_close(gz_sim_t *self);

extern int gz_sim_lock(gz_sim_t *self, int blocking);

extern void gz_sim_unlock(gz_sim_t *self);




/***************************************************************************/


#define GAZEBO_CAMERA_MAX_IMAGE_SIZE 640 * 480 * 3

typedef struct gz_camera_data
{
  gz_data_t head;

  double time;

  unsigned int width, height;

  unsigned int image_size;
  unsigned char image[GAZEBO_CAMERA_MAX_IMAGE_SIZE];
  
} gz_camera_data_t;


typedef struct gz_camera
{
  gz_iface_t *iface;

  gz_camera_data_t *data;
  
} gz_camera_t;


extern gz_camera_t *gz_camera_alloc();

extern void gz_camera_free(gz_camera_t *self);

extern int gz_camera_create(gz_camera_t *self, gz_server_t *server, const char *id,
                            const char *model_type, int model_id, int parent_model_id);

extern int gz_camera_destroy(gz_camera_t *self);

extern int gz_camera_open(gz_camera_t *self, gz_client_t *client, const char *id);

extern int gz_camera_close(gz_camera_t *self);

extern int gz_camera_lock(gz_camera_t *self, int blocking);

extern void gz_camera_unlock(gz_camera_t *self);

extern int gz_camera_post(gz_camera_t *self);




/***************************************************************************/


typedef struct gz_factory_data
{
  gz_data_t head;

  double time;

  uint8_t string[4096];
  
} gz_factory_data_t;


typedef struct gz_factory
{
  gz_iface_t *iface;

  gz_factory_data_t *data;
  
} gz_factory_t;


extern gz_factory_t *gz_factory_alloc();

extern void gz_factory_free(gz_factory_t *self);

extern int gz_factory_create(gz_factory_t *self, gz_server_t *server, const char *id,
                             const char *model_type, int model_id, int parent_model_id);

extern int gz_factory_destroy(gz_factory_t *self);

extern int gz_factory_open(gz_factory_t *self, gz_client_t *client, const char *id);

extern int gz_factory_close(gz_factory_t *self);

extern int gz_factory_lock(gz_factory_t *self, int blocking);

extern void gz_factory_unlock(gz_factory_t *self);




/***************************************************************************/

#define GZ_FIDUCIAL_MAX_FIDS 401

typedef struct gz_fiducial_fid
{
  int id;

  double pos[3];

  double rot[3];

} gz_fiducial_fid_t;


typedef struct gz_fiducial_data
{
  gz_data_t head;

  double time;
  
  int fid_count;
  gz_fiducial_fid_t fids[GZ_FIDUCIAL_MAX_FIDS];
  
} gz_fiducial_data_t;


typedef struct gz_fiducial
{
  gz_iface_t *iface;

  gz_fiducial_data_t *data;
  
} gz_fiducial_t;


extern gz_fiducial_t *gz_fiducial_alloc();

extern void gz_fiducial_free(gz_fiducial_t *self);

extern int gz_fiducial_create(gz_fiducial_t *self, gz_server_t *server, const char *id,
                              const char *model_type, int model_id, int parent_model_id);

extern int gz_fiducial_destroy(gz_fiducial_t *self);

extern int gz_fiducial_open(gz_fiducial_t *self, gz_client_t *client, const char *id);

extern int gz_fiducial_close(gz_fiducial_t *self);

extern int gz_fiducial_lock(gz_fiducial_t *self, int blocking);

extern void gz_fiducial_unlock(gz_fiducial_t *self);

extern int gz_fiducial_post(gz_fiducial_t *self);




/***************************************************************************/


#define GAZEBO_GUICAM_MAX_IMAGE_SIZE 1024 * 768 * 3

typedef struct gz_guicam_data
{
  gz_data_t head;

  double sim_time;

  double pause_time;
  
  double pos[3];

  double rot[3];

  int cmd_spot_mode;
  
  int cmd_spot_state;
  
  double cmd_spot_a[2], cmd_spot_b[2];
  
  int roll_lock;

  int display_bbox;

  int display_axes;

  int display_com;

  int display_skins;

  int display_rays;

  int display_frustrums;

  int display_materials;

  int display_textures;

  int polygon_fill;

  int shade_smooth;

  int save_frames;

  unsigned int width, height;

  unsigned char image[GAZEBO_GUICAM_MAX_IMAGE_SIZE];
  unsigned int image_size;
  
} gz_guicam_data_t;


typedef struct gz_guicam
{
  gz_iface_t *iface;

  gz_guicam_data_t *data;
  
} gz_guicam_t;


extern gz_guicam_t *gz_guicam_alloc();

extern void gz_guicam_free(gz_guicam_t *self);

extern int gz_guicam_create(gz_guicam_t *self, gz_server_t *server, const char *id,
                            const char *model_type, int model_id, int parent_model_id);

extern int gz_guicam_destroy(gz_guicam_t *self);

extern int gz_guicam_open(gz_guicam_t *self, gz_client_t *client, const char *id);

extern int gz_guicam_close(gz_guicam_t *self);

extern int gz_guicam_lock(gz_guicam_t *self, int blocking);

extern void gz_guicam_unlock(gz_guicam_t *self);

extern int gz_guicam_post(gz_guicam_t *self);




/***************************************************************************/


typedef struct gz_gps_data
{
  gz_data_t head;
  
  double time;

  double utc_time;

  double latitude;

  double longitude;

  double altitude;

  double utm_e, utm_n;

  int satellites;

  int quality;
    
  double hdop;

  double vdop;

  double err_horz, err_vert;
  
} gz_gps_data_t;


typedef struct gz_gps
{
  gz_iface_t *iface;

  gz_gps_data_t *data;
  
} gz_gps_t;


extern gz_gps_t *gz_gps_alloc();

extern void gz_gps_free(gz_gps_t *self);

extern int gz_gps_create(gz_gps_t *self, gz_server_t *server, const char *id,
                         const char *model_type, int model_id, int parent_model_id);

extern int gz_gps_destroy(gz_gps_t *self);

extern int gz_gps_open(gz_gps_t *self, gz_client_t *client, const char *id);

extern int gz_gps_close(gz_gps_t *self);

extern int gz_gps_lock(gz_gps_t *self, int blocking);

extern void gz_gps_unlock(gz_gps_t *self);

extern int gz_gps_post(gz_gps_t *self);





/***************************************************************************/

#define GAZEBO_GRIPPER_STATE_OPEN 1

#define GAZEBO_GRIPPER_STATE_CLOSED 2

#define GAZEBO_GRIPPER_STATE_MOVING 3

#define GAZEBO_GRIPPER_STATE_ERROR 4

#define GAZEBO_GRIPPER_CMD_OPEN 1

#define GAZEBO_GRIPPER_CMD_CLOSE 2

#define GAZEBO_GRIPPER_CMD_STOP 3

#define GAZEBO_GRIPPER_CMD_STORE 4

#define GAZEBO_GRIPPER_CMD_RETRIEVE 5

typedef struct gz_gripper_data
{
  gz_data_t head;

  double time;
 
  int cmd;

  int state;

  int grip_limit_reach;
  int lift_limit_reach;
  int outer_beam_obstruct;
  int inner_beam_obstruct;
  int left_paddle_open;
  int right_paddle_open;

  int lift_up;
  int lift_down;

} gz_gripper_data_t;


typedef struct gz_gripper
{
  gz_iface_t *iface;

  gz_gripper_data_t *data;
  
} gz_gripper_t;


extern gz_gripper_t *gz_gripper_alloc();

extern void gz_gripper_free(gz_gripper_t *self);

extern int gz_gripper_create(gz_gripper_t *self, gz_server_t *server, const char *id,
                             const char *model_type, int model_id, int parent_model_id);

extern int gz_gripper_destroy(gz_gripper_t *self);

extern int gz_gripper_open(gz_gripper_t *self, gz_client_t *client, const char *id);

extern int gz_gripper_close(gz_gripper_t *self);

extern int gz_gripper_lock(gz_gripper_t *self, int blocking);

extern void gz_gripper_unlock(gz_gripper_t *self);




/***************************************************************************/

#define GZ_LASER_MAX_RANGES 401

typedef struct gz_laser_data
{
  gz_data_t head;

  double time;
  
  double min_angle, max_angle;

  double res_angle;

  double max_range;

  int range_count;
  
  double ranges[GZ_LASER_MAX_RANGES];

  int intensity[GZ_LASER_MAX_RANGES];
  
  // New command ( 0 or 1 )
  int cmd_new_angle;
  int cmd_new_length;

  // Commanded range value
  double cmd_max_range;
  double cmd_min_angle, cmd_max_angle;
  int cmd_range_count;

} gz_laser_data_t;


typedef struct gz_laser
{
  gz_iface_t *iface;

  gz_laser_data_t *data;
  
} gz_laser_t;


extern gz_laser_t *gz_laser_alloc();

extern void gz_laser_free(gz_laser_t *self);

extern int gz_laser_create(gz_laser_t *self, gz_server_t *server, const char *id,
                           const char *model_type, int model_id, int parent_model_id);

extern int gz_laser_destroy(gz_laser_t *self);

extern int gz_laser_open(gz_laser_t *self, gz_client_t *client, const char *id);

extern int gz_laser_close(gz_laser_t *self);

extern int gz_laser_lock(gz_laser_t *self, int blocking);

extern void gz_laser_unlock(gz_laser_t *self);

extern int gz_laser_post(gz_laser_t *self);




/***************************************************************************/


typedef struct gz_position_data
{
  gz_data_t head;

  double time;

  double pos[3];
  double rot[3];

  double vel_pos[3];
  double vel_rot[3];

  int stall;

  int cmd_enable_motors;
  
  double cmd_vel_pos[3];
  double cmd_vel_rot[3];
  
} gz_position_data_t;


typedef struct gz_position
{
  gz_iface_t *iface;

  gz_position_data_t *data;
  
} gz_position_t;


extern gz_position_t *gz_position_alloc();

extern void gz_position_free(gz_position_t *self);

extern int gz_position_create(gz_position_t *self, gz_server_t *server, const char *id,
                              const char *model_type, int model_id, int parent_model_id);

extern int gz_position_destroy(gz_position_t *self);

extern int gz_position_open(gz_position_t *self, gz_client_t *client, const char *id);

extern int gz_position_close(gz_position_t *self);

extern int gz_position_lock(gz_position_t *self, int blocking);

extern void gz_position_unlock(gz_position_t *self);

extern int gz_position_post(gz_position_t *self);




/***************************************************************************/


typedef struct gz_power_data
{
  gz_data_t head;

  double time;

  double levels[10];
  
} gz_power_data_t;


typedef struct gz_power
{
  gz_iface_t *iface;

  gz_power_data_t *data;
  
} gz_power_t;


extern gz_power_t *gz_power_alloc();

extern void gz_power_free(gz_power_t *self);

extern int gz_power_create(gz_power_t *self, gz_server_t *server, const char *id,
                           const char *model_type, int model_id, int parent_model_id);

extern int gz_power_destroy(gz_power_t *self);

extern int gz_power_open(gz_power_t *self, gz_client_t *client, const char *id);

extern int gz_power_close(gz_power_t *self);

extern int gz_power_lock(gz_power_t *self, int blocking);

extern void gz_power_unlock(gz_power_t *self);

extern int gz_power_post(gz_power_t *self);




/***************************************************************************/


typedef struct gz_ptz_data
{
  gz_data_t head;
  
  double time;

  double pan, tilt;

  double zoom;

  double cmd_pan, cmd_tilt;

  double cmd_zoom;
  
} gz_ptz_data_t;


typedef struct gz_ptz
{
  gz_data_t head;
  
  gz_iface_t *iface;

  gz_ptz_data_t *data;
  
} gz_ptz_t;


extern gz_ptz_t *gz_ptz_alloc();

extern void gz_ptz_free(gz_ptz_t *self);

extern int gz_ptz_create(gz_ptz_t *self, gz_server_t *server, const char *id,
                         const char *model_type, int model_id, int parent_model_id);

extern int gz_ptz_destroy(gz_ptz_t *self);

extern int gz_ptz_open(gz_ptz_t *self, gz_client_t *client, const char *id);

extern int gz_ptz_close(gz_ptz_t *self);

extern int gz_ptz_lock(gz_ptz_t *self, int blocking);

extern void gz_ptz_unlock(gz_ptz_t *self);

extern int gz_ptz_post(gz_ptz_t *self);





/***************************************************************************/

#define GAZEBO_ACTARRAY_NUM_ACTUATORS 16
#define GAZEBO_ACTARRAY_JOINT_POSITION_MODE 0
#define GAZEBO_ACTARRAY_JOINT_SPEED_MODE 1
#define GAZEBO_ACTARRAY_JOINT_CURRENT_MODE 2

#define GAZEBO_ACTARRAY_ACTSTATE_IDLE     1

#define GAZEBO_ACTARRAY_ACTSTATE_MOVING   2

#define GAZEBO_ACTARRAY_ACTSTATE_BRAKED   3

#define GAZEBO_ACTARRAY_ACTSTATE_STALLED  4


typedef struct gazebo_actarray_actuator
{
  float position;
  float speed;
  uint8_t state;
} gazebo_actarray_actuator_t;

//TODO: Extend this for the complete interface
typedef struct gz_actarray_data
{
  gz_data_t head;
  
  double time;
  
  // Timestamp for commands;
  unsigned int new_cmd;

  uint32_t actuators_count;
  gazebo_actarray_actuator_t actuators_data[GAZEBO_ACTARRAY_NUM_ACTUATORS];
  //gazebo_actarray_actuatorgeom_t actuators_geom[GAZEBO_ACTARRAY_NUM_ACTUATORS];
  //gazebo_point_3d_t base_pos;
  //gazebo_orientation_3d_t base_orientation;  
   float cmd_pos[GAZEBO_ACTARRAY_NUM_ACTUATORS];
   float cmd_speed[GAZEBO_ACTARRAY_NUM_ACTUATORS];
   float cmd_current[GAZEBO_ACTARRAY_NUM_ACTUATORS];
   unsigned int joint_mode[GAZEBO_ACTARRAY_NUM_ACTUATORS];  //Position/Speed/Current mode

} gz_actarray_data_t;


typedef struct gz_actarray
{
  gz_data_t head;
  
  gz_iface_t *iface;

  gz_actarray_data_t *data;
  
} gz_actarray_t;


extern gz_actarray_t *gz_actarray_alloc();

extern void gz_actarray_free(gz_actarray_t *self);

extern int gz_actarray_create(gz_actarray_t *self, gz_server_t *server, const char *id,
                         const char *model_type, int model_id, int parent_model_id);

extern int gz_actarray_destroy(gz_actarray_t *self);

extern int gz_actarray_open(gz_actarray_t *self, gz_client_t *client, const char *id);

extern int gz_actarray_close(gz_actarray_t *self);

extern int gz_actarray_lock(gz_actarray_t *self, int blocking);

extern void gz_actarray_unlock(gz_actarray_t *self);

extern int gz_actarray_post(gz_actarray_t *self);








/***************************************************************************/

#define GZ_SONAR_MAX_RANGES 48

typedef struct gz_sonar_data
{
  gz_data_t head;

  double time;

  double max_range;

  int sonar_count;

  double sonar_pos[GZ_SONAR_MAX_RANGES][3];

  double sonar_rot[GZ_SONAR_MAX_RANGES][3];

  double sonar_ranges[GZ_SONAR_MAX_RANGES];
  
  int cmd_enable_sonar;

} gz_sonar_data_t;


typedef struct gz_sonar
{
  gz_iface_t *iface;

  gz_sonar_data_t *data;

} gz_sonar_t;


extern gz_sonar_t *gz_sonar_alloc();

extern void gz_sonar_free(gz_sonar_t *self);

extern int gz_sonar_create(gz_sonar_t *self, gz_server_t *server, const char *id,
                           const char *model_type, int model_id, int parent_model_id);

extern int gz_sonar_destroy(gz_sonar_t *self);

extern int gz_sonar_open(gz_sonar_t *self, gz_client_t *client, const char *id);

extern int gz_sonar_close(gz_sonar_t *self);

extern int gz_sonar_lock(gz_sonar_t *self, int blocking);

extern void gz_sonar_unlock(gz_sonar_t *self);


//
/***************************************************************************/

#define GZ_IR_MAX_RANGES 48

typedef struct gz_ir_data
{
  gz_data_t head;

  double time;

  double max_range;

  int ir_count;

  double ir_pos[GZ_IR_MAX_RANGES][3];

  double ir_rot[GZ_IR_MAX_RANGES][3];

  double ir_ranges[GZ_IR_MAX_RANGES];
  
  int cmd_enable_ir;

} gz_ir_data_t;


typedef struct gz_ir
{
  gz_iface_t *iface;

  gz_ir_data_t *data;

} gz_ir_t;


extern gz_ir_t *gz_ir_alloc();

extern void gz_ir_free(gz_ir_t *self);

extern int gz_ir_create(gz_ir_t *self, gz_server_t *server, const char *id,
                           const char *model_type, int model_id, int parent_model_id);

extern int gz_ir_destroy(gz_ir_t *self);

extern int gz_ir_open(gz_ir_t *self, gz_client_t *client, const char *id);

extern int gz_ir_close(gz_ir_t *self);

extern int gz_ir_lock(gz_ir_t *self, int blocking);

extern void gz_ir_unlock(gz_ir_t *self);





/***************************************************************************/


#define GAZEBO_STEREO_MAX_RGB_SIZE 640 * 480 * 3
#define GAZEBO_STEREO_MAX_DISPARITY_SIZE 640 * 480

typedef struct gz_stereo_data
{
  gz_data_t head;

  double time;

  unsigned int width, height;

  unsigned int left_image_size;
  unsigned char left_image[GAZEBO_STEREO_MAX_RGB_SIZE];

  unsigned int right_image_size;
  unsigned char right_image[GAZEBO_STEREO_MAX_RGB_SIZE];

  unsigned int left_disparity_size;
  float left_disparity[GAZEBO_STEREO_MAX_DISPARITY_SIZE];

  unsigned int right_disparity_size;
  float right_disparity[GAZEBO_STEREO_MAX_DISPARITY_SIZE];

} gz_stereo_data_t;


typedef struct gz_stereo
{
  gz_iface_t *iface;

  gz_stereo_data_t *data;
  
} gz_stereo_t;


extern gz_stereo_t *gz_stereo_alloc();

extern void gz_stereo_free(gz_stereo_t *self);

extern int gz_stereo_create(gz_stereo_t *self, gz_server_t *server, const char *id,
                            const char *model_type, int model_id, int parent_model_id);

extern int gz_stereo_destroy(gz_stereo_t *self);

extern int gz_stereo_open(gz_stereo_t *self, gz_client_t *client, const char *id);

extern int gz_stereo_close(gz_stereo_t *self);

extern int gz_stereo_lock(gz_stereo_t *self, int blocking);

extern void gz_stereo_unlock(gz_stereo_t *self);

extern int gz_stereo_post(gz_stereo_t *self);





/***************************************************************************/


typedef struct gz_truth_data
{
  gz_data_t head;

  double time;

  double pos[3];

  double rot[4];

  int cmd_new;
  
  double cmd_pos[3];

  double cmd_rot[4];
   
} gz_truth_data_t;


typedef struct gz_truth
{
  gz_iface_t *iface;

  gz_truth_data_t *data;
  
} gz_truth_t;


extern gz_truth_t *gz_truth_alloc();

extern void gz_truth_free(gz_truth_t *self);

extern int gz_truth_create(gz_truth_t *self, gz_server_t *server, const char *id,
                           const char *model_type, int model_id, int parent_model_id);

extern int gz_truth_destroy(gz_truth_t *self);

extern int gz_truth_open(gz_truth_t *self, gz_client_t *client, const char *id);

extern int gz_truth_close(gz_truth_t *self);

extern int gz_truth_lock(gz_truth_t *self, int blocking);

extern void gz_truth_unlock(gz_truth_t *self);

extern int gz_truth_post(gz_truth_t *self);

extern void gz_truth_euler_from_quatern(gz_truth_t *self, double *e, double *q);

extern void gz_truth_quatern_from_euler(gz_truth_t *self, double *q, double *e);




/***************************************************************************/

#define GAZEBO_WIFI_MAX_LINKS 16

#define GAZEBO_WIFI_QUAL_DBM            1

typedef struct gz_wifi_link
{
  char ip[32];

  uint16_t qual, level, noise;
  
} gz_wifi_link_t;


typedef struct gz_wifi_data
{
  gz_data_t head;

  double time;

  gz_wifi_link_t links[GAZEBO_WIFI_MAX_LINKS];
  uint16_t link_count;

} gz_wifi_data_t;


typedef struct gz_wifi
{
  gz_iface_t *iface;

  gz_wifi_data_t *data;
  
} gz_wifi_t;


extern gz_wifi_t *gz_wifi_alloc();

extern void gz_wifi_free(gz_wifi_t *self);

extern int gz_wifi_create(gz_wifi_t *self, gz_server_t *server, const char *id,
                          const char *model_type, int model_id, int parent_model_id);

extern int gz_wifi_destroy(gz_wifi_t *self);

extern int gz_wifi_open(gz_wifi_t *self, gz_client_t *client, const char *id);

extern int gz_wifi_close(gz_wifi_t *self);

extern int gz_wifi_lock(gz_wifi_t *self, int blocking);

extern void gz_wifi_unlock(gz_wifi_t *self);




/***************************************************************************/

#define GAZEBO_JOINT_MAX_JOINTS 20

typedef struct gz_joint_data
{
  int type;
 
  double anchor[3];

  double axis[3];

  double axis2[3];

  double angular_velocity;

  double angular_velocity2;

  double angle;

  double angle2;

  double cmd_angle;

  double cmd_angle2;

} gz_joint_data_t;

typedef struct gz_joints
{
  gz_data_t head;

  double time;

  gz_joint_data_t joints[GAZEBO_JOINT_MAX_JOINTS];

  int joint_count;

} gz_joints_t;


typedef struct gz_joint
{
  gz_iface_t *iface;

  gz_joints_t *data;
  
} gz_joint_t;


extern gz_joint_t *gz_joint_alloc();

extern void gz_joint_free(gz_joint_t *self);

extern int gz_joint_create(gz_joint_t *self, gz_server_t *server, const char *id, const char *model_type, int model_id, int parent_model_id);

extern int gz_joint_destroy(gz_joint_t *self);

extern int gz_joint_open(gz_joint_t *self, gz_client_t *client, const char *id);

extern int gz_joint_close(gz_joint_t *self);

extern int gz_joint_lock(gz_joint_t *self, int blocking);

extern void gz_joint_unlock(gz_joint_t *self);

extern int gz_joint_post(gz_joint_t *self);






#ifdef __cplusplus
}
#endif

#endif

---

Last updated 12 September 2005 21:38:45