gazebo.h

机器人人3D仿真工具,可以加入到Simbad仿真环境下应用。

  
} gz_factory_data_t;


/// The position interface
typedef struct gz_factory
{
  /// General interface info
  gz_iface_t *iface;

  /// Pointer to interface data area
  gz_factory_data_t *data;
  
} gz_factory_t;


/// Create an interface
extern gz_factory_t *gz_factory_alloc();

/// Destroy an interface
extern void gz_factory_free(gz_factory_t *self);

/// @internal Create the interface (used by Gazebo server)
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);

/// @internal Destroy the interface (server)
extern int gz_factory_destroy(gz_factory_t *self);

/// Open an existing interface (used by Gazebo clients)
extern int gz_factory_open(gz_factory_t *self, gz_client_t *client, const char *id);

/// Close the interface (client)
extern int gz_factory_close(gz_factory_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_factory_lock(gz_factory_t *self, int blocking);

/// Unlock the interface
extern void gz_factory_unlock(gz_factory_t *self);

/** @} */
/// @}


/***************************************************************************/
/// @addtogroup libgazebo 
/// @{
/** @defgroup fiducial fiducial

The fiducial interface allows clients to determine the identity,
range, bearing and orientation (relative to some sensor) of objects in
the world.  For example, this interface is used by the SickLMS200
model to return data from simulated retro-reflective barcodes.

@{
*/

#define GZ_FIDUCIAL_MAX_FIDS 401

/// Data for a single fiducial
typedef struct gz_fiducial_fid
{
  /// Fiducial id
  int id;

  /// Fiducial position relative to sensor (x, y, z).
  double pos[3];

  /// Fiducial orientation relative to sensor (roll, pitch, yaw).
  double rot[3];

} gz_fiducial_fid_t;


/// Fiducial data
typedef struct gz_fiducial_data
{
  /// Common data structures
  gz_data_t head;

  /// Data timestamp
  double time;
  
  /// Observed fiducials
  int fid_count;
  gz_fiducial_fid_t fids[GZ_FIDUCIAL_MAX_FIDS];
  
} gz_fiducial_data_t;


/// The fiducial interface
typedef struct gz_fiducial
{
  /// General interface info
  gz_iface_t *iface;

  /// Pointer to interface data area
  gz_fiducial_data_t *data;
  
} gz_fiducial_t;


/// Create an interface
extern gz_fiducial_t *gz_fiducial_alloc();

/// Destroy an interface
extern void gz_fiducial_free(gz_fiducial_t *self);

/// @internal Create the interface (used by Gazebo server)
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);

/// @internal Destroy the interface (server)
extern int gz_fiducial_destroy(gz_fiducial_t *self);

/// Open an existing interface (used by Gazebo clients)
extern int gz_fiducial_open(gz_fiducial_t *self, gz_client_t *client, const char *id);

/// Close the interface (client)
extern int gz_fiducial_close(gz_fiducial_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_fiducial_lock(gz_fiducial_t *self, int blocking);

/// Unlock the interface
extern void gz_fiducial_unlock(gz_fiducial_t *self);

/// Tell clients that new data is available
extern int gz_fiducial_post(gz_fiducial_t *self);

/** @} */
/// @}


/***************************************************************************/
/// @addtogroup libgazebo 
/// @{
/** @defgroup guicam guicam 

The GuiCam interface provides access to user-controllable cameras
(i.e., a gods-eye view for monitoring a running simulation).  This interface
is used by monitoring GUIs such as wxgazebo.

@{
*/

/// Constants
#define GAZEBO_GUICAM_MAX_IMAGE_SIZE 1024 * 768 * 3

/// Guicam interface data
typedef struct gz_guicam_data
{
  /// Common data structure
  gz_data_t head;

  /// Data timestamp (simulator time)
  double sim_time;

  /// Accumpated pause time (this interface may be updated with the
  /// server is paused).
  double pause_time;
  
  /// True object position (x, y, x)
  double pos[3];

  /// True object rotation (roll, pitch, yaw)
  double rot[3];

  /// Spot mode (0 = translate; 1 = zoom; 2 = rotate)
  int cmd_spot_mode;
  
  /// Spot state (0 = none; 1 = moving)
  int cmd_spot_state;
  
  /// Spot transform points (image coordinates)
  double cmd_spot_a[2], cmd_spot_b[2];
  
  /// Lock the roll (so that the image y axis corresponds to world z
  /// axis)
  int roll_lock;

  /// Display bounding boxes
  int display_bbox;

  /// Display body axes
  int display_axes;

  /// Display CoM axes
  int display_com;

  /// Display skins
  int display_skins;

  /// Display sensor rays
  int display_rays;

  /// Display sensor frustrums
  int display_frustrums;

  /// Display materials
  int display_materials;

  /// Display textures
  int display_textures;

  /// Polygon mode: 0 = wireframe, 1 = filled
  int polygon_fill;

  /// Shade model: 0 = flat, 1 = smooth
  int shade_smooth;

  /// Save frames to disk
  int save_frames;

  /// Image dimensions (in pixels)
  unsigned int width, height;

  /// Image pixel data; format is packed RGB888
  unsigned char image[GAZEBO_GUICAM_MAX_IMAGE_SIZE];
  unsigned int image_size;
  
} gz_guicam_data_t;


/// The guicam interface
typedef struct gz_guicam
{
  /// General interface info
  gz_iface_t *iface;

  /// Pointer to interface data area
  gz_guicam_data_t *data;
  
} gz_guicam_t;


/// Create an interface
extern gz_guicam_t *gz_guicam_alloc();

/// Destroy an interface
extern void gz_guicam_free(gz_guicam_t *self);

/// @internal Create the interface (used by Gazebo server)
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);

/// @internal Destroy the interface (server)
extern int gz_guicam_destroy(gz_guicam_t *self);

/// Open an existing interface (used by Gazebo clients)
extern int gz_guicam_open(gz_guicam_t *self, gz_client_t *client, const char *id);

/// Close the interface (client)
extern int gz_guicam_close(gz_guicam_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_guicam_lock(gz_guicam_t *self, int blocking);

/// Unlock the interface
extern void gz_guicam_unlock(gz_guicam_t *self);

/// Tell clients that new data is available
extern int gz_guicam_post(gz_guicam_t *self);

/** @} */
/// @}


/***************************************************************************/
/// @addtogroup libgazebo 
/// @{
/** @defgroup gps gps

The gps interface allows the user to receive GPS
(Latitude/Longitude/Altitude) information for the robot platform on
which the GPS device is mounted.

@{
*/

/// GPS interface
typedef struct gz_gps_data
{
  /// Common data structure
  gz_data_t head;
  
  /// Data timestamp
  double time;

  /// UTC timestamp
  double utc_time;

  /// Latitude in degrees.
  double latitude;

  /// Longitude in degrees.
  double longitude;

  /// Altitude, in meters.
  double altitude;

  /// UTM coordinates (meters)
  double utm_e, utm_n;

  /// Number of satellites in view.
  int satellites;

  /// Fix quality
  int quality;
    
  /// Horizontal dilution of position (HDOP)
  double hdop;

  /// Vertical dilution of position (VDOP)
  double vdop;

  /// Errors
  double err_horz, err_vert;
  
} gz_gps_data_t;


/// The GPS interface
typedef struct gz_gps
{
  /// General interface info
  gz_iface_t *iface;

  /// Pointer to interface data area
  gz_gps_data_t *data;
  
} gz_gps_t;


/// Create an interface
extern gz_gps_t *gz_gps_alloc();

/// Destroy an interface
extern void gz_gps_free(gz_gps_t *self);

/// @internal Create the interface (used by Gazebo server)
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);

/// @internal Destroy the interface (server)
extern int gz_gps_destroy(gz_gps_t *self);

/// Open an existing interface (used by Gazebo clients)
extern int gz_gps_open(gz_gps_t *self, gz_client_t *client, const char *id);

/// Close the interface (client)
extern int gz_gps_close(gz_gps_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_gps_lock(gz_gps_t *self, int blocking);

/// Unlock the interface
extern void gz_gps_unlock(gz_gps_t *self);

/// Tell clients that new data is available
extern int gz_gps_post(gz_gps_t *self);

/** @} */
/// @}



/***************************************************************************/
/// @addtogroup libgazebo 
/// @{
/** @defgroup gripper gripper

The gripper interface allows control of a simple 2-DOF gripper, such as
that found on the Pioneer series robots.

@{
*/

/** Gripper state: open */
#define GAZEBO_GRIPPER_STATE_OPEN 1
/** Gripper state: closed */
#define GAZEBO_GRIPPER_STATE_CLOSED 2
/** Gripper state: moving */
#define GAZEBO_GRIPPER_STATE_MOVING 3
/** Gripper state: error */
#define GAZEBO_GRIPPER_STATE_ERROR 4

/** Gripper command: open */
#define GAZEBO_GRIPPER_CMD_OPEN 1
/** Gripper command: close */
#define GAZEBO_GRIPPER_CMD_CLOSE 2
/** Gripper command: stop */
#define GAZEBO_GRIPPER_CMD_STOP 3
/** Gripper command: store */
#define GAZEBO_GRIPPER_CMD_STORE 4
/** Gripper command: retrieve */
#define GAZEBO_GRIPPER_CMD_RETRIEVE 5

/// Gripper data interface
typedef struct gz_gripper_data
{
  /// Common data structures
  gz_data_t head;

  /// Data timestamp
  double time;
 
  /// Current command for the gripper
  int cmd;

  /// Current state of the gripper
  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;


/// The gripper interface
typedef struct gz_gripper
{
  /// General interface info
  gz_iface_t *iface;

  /// Pointer to interface data area
  gz_gripper_data_t *data;
  
} gz_gripper_t;


/// Create an interface
extern gz_gripper_t *gz_gripper_alloc();

/// Destroy an interface
extern void gz_gripper_free(gz_gripper_t *self);

/// @internal Create the interface (used by Gazebo server)
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);

/// @internal Destroy the interface (server)
extern int gz_gripper_destroy(gz_gripper_t *self);

/// Open an existing interface (used by Gazebo clients)
extern int gz_gripper_open(gz_gripper_t *self, gz_client_t *client, const char *id);

/// Close the interface (client)
extern int gz_gripper_close(gz_gripper_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_gripper_lock(gz_gripper_t *self, int blocking);

/// Unlock the interface
extern void gz_gripper_unlock(gz_gripper_t *self);

/** @} */
/// @}


/***************************************************************************/
/// @addtogroup libgazebo
/// @{
/** @defgroup laser laser

The laser interface allows clients to read data from a simulated laser
range finder (such as the SICK LMS200).  Some configuration of this
device is also allowed.

@{
*/

#define GZ_LASER_MAX_RANGES 401

/// Laser data
typedef struct gz_laser_data
{
  /// Common data structures
  gz_data_t head;

  /// Data timestamp
  double time;
  
  /// Range scan angles