Gazebo

User

Frontpage

Installation

Worldfile Syntax

GUI

Media Resources

Tutorials

Model Creation

Sensor Creation

Controller Creation

Using Player

Using Terrains

Creating Custom Meshes

API

Code Reference

Class List

Class Hierarchy

gazebo.h

/*
 *  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
 * SVN: $Id: gazebo.h 6338 2008-04-16 17:24:32Z natepak $
 */

#ifndef GAZEBO_H
#define GAZEBO_H

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

#include "IfaceFactory.hh"

namespace gazebo
{


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


#define LIBGAZEBO_VERSION 0x070



class Vec3
{
  public: double x;

  public: double y;

  public: double z;
};


class Pose
{
  public: Vec3 pos;

  public: double roll;

  public: double pitch;

  public: double yaw; 
};

class Color
{
  public: float r;

  public: float g;

  public: float b;

  public: float a;
};

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


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

class Server
{
  public: Server();

  public: virtual ~Server();

  public: void Init(int serverId, int force);

  public: void Fini();

  public: void Post();

  private: void SemInit(int force);
  private: void SemFini();
  private: void SemPost();

  public: int serverId;

  public: std::string filename;

  public: int semKey;

  public: int semId;
};

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

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

#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

  
class Client 
{
  public: Client();

  public: virtual ~Client();

  public: void Query(int server_id);

  public: void Connect(int server_id);

  public: void ConnectWait(int server_id, int client_id);

  public: void Disconnect();

  public: void Wait();

  private: void SemQuery(int server_id);
  private: void SemInit();
  private: void SemFini();
  private: void SemWait();

  public: int serverId;

  public: int clientId;

  public: std::string filename;

  public: int semKey;

  public: int semId;
};

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

#define GAZEBO_MAX_MODEL_TYPE 128

class Iface
{
  public: Iface(const std::string &type, size_t size);

  public: virtual ~Iface();

  public: virtual void Create(Server *server, std::string id);

  public: void Create(Server *server, std::string id,
              const std::string &modelType, int modelId, 
              int parentModelId);

  public: void Destroy();

  public: virtual void Open(Client *client, std::string id);

  public: virtual void Close();

  public: int Lock(int blocking);

  public: int Unlock();

  public: void Post();

  public: int GetOpenCount();

  public: std::string GetType() const;

  private: std::string Filename(std::string id);

  public: Server *server;

  public: Client *client;

  public: int mmapFd;

  public: void *mMap;

  public: std::string filename;

  protected: std::string type;

  private: bool creator;

  private: size_t size;
};

class GazeboData
{
  public: int openCount;

  public: double time;

  public: int version;

  public: size_t size;

  public: int modelId;

  public: int parentModelId;

  public: std::string modelType;


};

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


class SimulationData
{
  public: GazeboData head;

  public: double simTime;

  public: double pauseTime;

  public: double realTime;

  public: int state;
  
  public: bool pause;

  public: int reset;

  public: int save;

  public: char model_name[512];

  public: char model_req[32];

  public: Pose model_pose;
};

class SimulationIface : public Iface
{
  public: SimulationIface(): Iface("simulation",sizeof(SimulationIface)+sizeof(SimulationData)) {}

  public: virtual ~SimulationIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (SimulationData*)((char*)this->mMap+sizeof(SimulationIface)); 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (SimulationData*)((char*)this->mMap+sizeof(SimulationIface)); 
          }

  public: SimulationData *data;
};




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

#define GAZEBO_MAX_URL_SIZE 256

class AudioData
{
  public: GazeboData head;

  public: double time;

  public: bool loop;

  public: float gain;

  public: bool stream;

  public: int cmd_play;

  public: int cmd_pause;

  public: int cmd_stop;
  
  public: int cmd_reset;
  
  public: int state;
 
  public: char url[GAZEBO_MAX_URL_SIZE];

  public: Pose audio_pose;
  
};

class AudioIface : public Iface
{
  public: AudioIface():Iface("audio", sizeof(AudioIface)+sizeof(AudioData)) {}

  public: virtual ~AudioIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (AudioData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (AudioData*)this->mMap; 
          }

  public: AudioData *data;
};






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


#define GAZEBO_CAMERA_MAX_IMAGE_SIZE 640 * 480 * 3

class CameraData
{
  public: GazeboData head;

  public: unsigned int width;

  public: unsigned int height;

  public: unsigned int image_size;

  public: unsigned char image[GAZEBO_CAMERA_MAX_IMAGE_SIZE];

  public: double hfov;

  public: Pose camera_pose;
  
};

class CameraIface : public Iface
{
  public: CameraIface():Iface("camera", sizeof(CameraIface)+sizeof(CameraData)) {}

  public: virtual ~CameraIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (CameraData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (CameraData*)this->mMap; 
          }

  public: CameraData *data;
};





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


class PositionData 
{
  public: GazeboData head;

  public: Pose pose;

  public: Pose velocity;

  public: int stall;

  public: int cmdEnableMotors;
  
  public: Pose cmdVelocity;
};

class PositionIface : public Iface
{
  public: PositionIface():Iface("position", sizeof(PositionIface)+sizeof(PositionData)) {}

  public: virtual ~PositionIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (PositionData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (PositionData*)this->mMap; 
          }

  public: PositionData *data;
};



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


#define GAZEBO_GRAPHICS3D_MAX_POINTS 1024

class Graphics3dData
{
  enum DrawMode {POINTS, LINES, LINE_STRIP, LINE_LOOP, TRIANGLES, TRIANGLE_STRIP, TRIANGLE_FAN, QUADS, QUAD_STRIP, POLYGON};

  public: DrawMode drawmode;

  public: unsigned int point_count; 

  public: Vec3 points[GAZEBO_GRAPHICS3D_MAX_POINTS];

  public: Color color;
};

class Graphics3dIface : public Iface
{

  public: Graphics3dIface():Iface("graphics3d", sizeof(Graphics3dIface)+sizeof(Graphics3dData)) {}

  public: virtual ~Graphics3dIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (Graphics3dData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (Graphics3dData*)this->mMap; 
          }


  public: Graphics3dData *data;
};





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


#define GZ_LASER_MAX_RANGES 1024

class LaserData
{
  public: GazeboData head;
  
  public: double min_angle;

  public: double max_angle;

  public: double res_angle;

  public: double max_range;

  public: int range_count;
  
  public: double ranges[GZ_LASER_MAX_RANGES];

  public: int intensity[GZ_LASER_MAX_RANGES];
  
  public: int cmd_new_angle;

  public: int cmd_new_length;

  public: double cmd_max_range;

  public: double cmd_min_angle;

  public: double cmd_max_angle;

  public: int cmd_range_count;
};

class LaserIface : public Iface
{
  public: LaserIface():Iface("laser", sizeof(LaserIface)+sizeof(LaserData)) {}

  public: virtual ~LaserIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (LaserData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (LaserData*)this->mMap; 
          }

  public: LaserData *data;
};




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


#define GZ_FIDUCIAL_MAX_FIDS 401

class FiducialFid
{

  public: int id;

  public: Pose pose;
};

class FiducialData
{
  public: GazeboData head;

  public: int count;

  public: FiducialFid fids[GZ_FIDUCIAL_MAX_FIDS];
};

class FiducialIface : public Iface
{
  public: FiducialIface():Iface("fiducial", sizeof(FiducialIface)+sizeof(FiducialData)) {}

  public: virtual ~FiducialIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (FiducialData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (FiducialData*)this->mMap; 
          }

  public: FiducialData *data;
};



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


class FactoryData 
{
  public: GazeboData head;

  public: uint8_t newModel[4096];

  public: uint8_t deleteModel[512];
};

class FactoryIface : public Iface
{
  public: FactoryIface():Iface("factory", sizeof(FactoryIface)+sizeof(FactoryData)) {}

  public: virtual ~FactoryIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (FactoryData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (FactoryData*)this->mMap; 
          }

  public: FactoryData *data;
};



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

#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


class GripperData
{
  public: GazeboData head;

  public: int cmd;

  public: int state;

  public: int grip_limit_reach;

  public: int lift_limit_reach;

  public: int outer_beam_obstruct;

  public: int inner_beam_obstruct;

  public: int left_paddle_open;

  public: int right_paddle_open;

  public: int lift_up;

  public: int lift_down;
};

class GripperIface : public Iface
{
  public: GripperIface():Iface("gripper", sizeof(GripperIface)+sizeof(GripperData)) {}

  public: virtual ~GripperIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (GripperData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (GripperData*)this->mMap; 
          }

  public: GripperData *data;
};




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


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

//Actuator states
#define GAZEBO_ACTARRAY_ACTSTATE_IDLE     1

#define GAZEBO_ACTARRAY_ACTSTATE_MOVING   2

#define GAZEBO_ACTARRAY_ACTSTATE_BRAKED   3

#define GAZEBO_ACTARRAY_ACTSTATE_STALLED  4

#define GAZEBO_ACTARRAY_TYPE_LINEAR       1
#define GAZEBO_ACTARRAY_TYPE_ROTARY       2

#define GAZEBO_ACTARRAY_POWER_REQ         1
#define GAZEBO_ACTARRAY_BRAKES_REQ        2
#define GAZEBO_ACTARRAY_GET_GEOM_REQ      3
#define GAZEBO_ACTARRAY_SPEED_REQ         4

#define GAZEBO_ACTARRAY_POS_CMD           1
#define GAZEBO_ACTARRAY_SPEED_CMD         2
#define GAZEBO_ACTARRAY_HOME_CMD          3


class ActarrayActuatorGeom
{

#define GAZEBO_ACTARRAY_DATA_STATE        1


  public: uint8_t type;

  public: float min;

  public: float center;

  public: float max;

  public: float home;

  public: float config_speed;

  public: float max_speed;

  public: uint8_t hasbrakes;
};

class ActarrayActuator
{
  public: float position;
  public: float speed;
  public: uint8_t state;

}; 

class ActarrayData
{
  public: GazeboData head;

  public: unsigned int actuators_count;
  
  public: ActarrayActuator actuators[GAZEBO_ACTARRAY_MAX_NUM_ACTUATORS];
  
  public: ActarrayActuatorGeom actuator_geoms[GAZEBO_ACTARRAY_MAX_NUM_ACTUATORS];
  
  public: float cmd_pos[GAZEBO_ACTARRAY_MAX_NUM_ACTUATORS];
  
  public: float cmd_speed[GAZEBO_ACTARRAY_MAX_NUM_ACTUATORS];
  
  public: int bad_cmd;

  public: bool new_cmd;
  
  public: unsigned int joint_mode[GAZEBO_ACTARRAY_MAX_NUM_ACTUATORS];
  
};

class ActarrayIface : public Iface
{
  public: ActarrayIface():Iface("actarray", sizeof(ActarrayIface)+sizeof(ActarrayData)) {}

  public: virtual ~ActarrayIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
           Iface::Create(server,id); 
           this->data = (ActarrayData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (ActarrayData*)this->mMap; 
          }

  public: ActarrayData *data;
};




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


class PTZData
{
  public: GazeboData head;

  public: double pan;

  public: double tilt;

  public: double zoom;

  public: double cmd_pan;

  public: double cmd_tilt;

  public: double cmd_zoom;
  
}; 


class PTZIface : public Iface
{
  public: PTZIface():Iface("ptz", sizeof(PTZIface)+sizeof(PTZData)) {}

  public: virtual ~PTZIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (PTZData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (PTZData*)this->mMap; 
          }

  public: PTZData *data;
};




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

#define GAZEBO_STEREO_CAMERA_MAX_RGB_SIZE 640 * 480 * 3
#define GAZEBO_STEREO_CAMERA_MAX_DISPARITY_SIZE 640 * 480

class StereoCameraData
{
  public: GazeboData head;

  public: unsigned int width;

  public: unsigned int height;

  public: float farClip;

  public: float nearClip;

  public: unsigned int left_rgb_size;

  public: unsigned char left_rgb[GAZEBO_STEREO_CAMERA_MAX_RGB_SIZE];

  public: unsigned int right_rgb_size;

  public: unsigned char right_rgb[GAZEBO_STEREO_CAMERA_MAX_RGB_SIZE];

  public: unsigned int left_disparity_size;

  public: float left_disparity[GAZEBO_STEREO_CAMERA_MAX_DISPARITY_SIZE];

  public: unsigned int right_disparity_size;

  public: float right_disparity[GAZEBO_STEREO_CAMERA_MAX_DISPARITY_SIZE];
}; 


class StereoCameraIface : public Iface
{
  public: StereoCameraIface():Iface("stereo", sizeof(StereoCameraIface)+sizeof(StereoCameraData)) {}

  public: virtual ~StereoCameraIface() {this->data = NULL;}

  public: virtual void Create(Server *server, std::string id)
          {
            Iface::Create(server,id); 
            this->data = (StereoCameraData*)this->mMap; 
          }

  public: virtual void Open(Client *client, std::string id)
          {
            Iface::Open(client,id); 
            this->data = (StereoCameraData*)this->mMap; 
          }

  public: StereoCameraData *data;
};



}


#endif

---

Last updated Aug 04 2007