p_driver.h
Go to the documentation of this file.
00001 #ifndef _STAGE_PLAYER_DRIVER_H
00002 #define _STAGE_PLAYER_DRIVER_H
00003 
00004 #include <unistd.h>
00005 #include <string.h>
00006 #include <math.h>
00007 
00008 #include <libplayercore/playercore.h>
00009 
00010 #include "../libstage/stage.hh"
00011 
00012 #define DRIVER_ERROR(X) printf( "Stage driver error: %s\n", X )
00013 
00014 // foward declare;
00015 class Interface;
00016 class StgTime;
00017 
00018 class StgDriver : public Driver
00019 {
00020  public:
00021   // Constructor; need that
00022   StgDriver(ConfigFile* cf, int section);
00023 
00024   // Destructor
00025   ~StgDriver(void);
00026 
00027   // Must implement the following methods.
00028   virtual int Setup();
00029   virtual int Shutdown();
00030   virtual int ProcessMessage(QueuePointer &resp_queue,
00031                  player_msghdr * hdr,
00032                  void * data);
00033   virtual int Subscribe(QueuePointer &queue, player_devaddr_t addr);
00034   virtual int Unsubscribe(QueuePointer &queue, player_devaddr_t addr);
00035 
00038   virtual void Update();
00039 
00041   static Stg::World* world;
00042   static bool usegui;
00043 
00045   Interface* LookupDevice( player_devaddr_t addr );
00046 
00047   Stg::Model* LocateModel( char* basename,
00048                                     player_devaddr_t* addr,
00049                                     const std::string& type );
00050   
00051  protected:
00052 
00054     std::vector<Interface*> devices;
00055 };
00056 
00057 
00058 class Interface
00059 {
00060  public:
00061   Interface(player_devaddr_t addr,
00062             StgDriver* driver,
00063             ConfigFile* cf,
00064             int section );
00065 
00066   virtual ~Interface( void ){ /* TODO: clean up*/ };
00067 
00068   player_devaddr_t addr;
00069   double last_publish_time;
00070   double publish_interval_msec;
00071 
00072   StgDriver* driver; // the driver instance that created this device
00073 
00074   virtual int ProcessMessage(QueuePointer &resp_queue,
00075                      player_msghdr_t* hdr,
00076                  void* data) { return(-1); } // empty implementation
00077 
00078   virtual void Publish( void ){}; // do nothing
00079   virtual void Subscribe( void ){}; // do nothing
00080   virtual void Unsubscribe( void ){}; // do nothing
00081   virtual void Subscribe( QueuePointer &queue ){}; // do nothing
00082   virtual void Unsubscribe( QueuePointer &queue ){}; // do nothing};
00083 };
00084 
00085 class InterfaceSimulation : public Interface
00086 {
00087  public:
00088   InterfaceSimulation( player_devaddr_t addr,  StgDriver* driver,ConfigFile* cf, int section );
00089   virtual ~InterfaceSimulation( void ){ /* TODO: clean up*/ };
00090   virtual int ProcessMessage(QueuePointer & resp_queue,
00091                              player_msghdr_t* hdr,
00092                              void* data);
00093 };
00094 
00095 // base class for all interfaces that are associated with a model
00096 class InterfaceModel
00097 
00098  : public Interface
00099 {
00100  public:
00101   InterfaceModel( player_devaddr_t addr,
00102           StgDriver* driver,
00103           ConfigFile* cf,
00104           int section,
00105           const std::string& type );
00106 
00107   Stg::Model* mod;
00108 
00109   virtual ~InterfaceModel( void ){ /* TODO: clean up*/ };
00110 
00111   virtual void Subscribe( void ){ this->mod->Subscribe(); };
00112   virtual void Unsubscribe( void ){ this->mod->Unsubscribe(); };
00113 };
00114 
00115 
00116 class InterfacePosition : public InterfaceModel
00117 {
00118  public:
00119   InterfacePosition( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00120   virtual ~InterfacePosition( void ){ /* TODO: clean up*/ };
00121   virtual void Publish( void );
00122   virtual int ProcessMessage(QueuePointer & resp_queue,
00123                              player_msghdr_t* hdr,
00124                              void* data);
00125 };
00126 
00127 class InterfaceGripper : public InterfaceModel
00128 {
00129  public:
00130   InterfaceGripper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00131   virtual ~InterfaceGripper( void ){ /* TODO: clean up*/ };
00132   virtual int ProcessMessage(QueuePointer & resp_queue,
00133                              player_msghdr_t* hdr,
00134                              void* data);
00135   virtual void Publish( void );
00136 };
00137 
00138 class InterfaceWifi : public InterfaceModel
00139 {
00140  public:
00141   InterfaceWifi( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00142   virtual ~InterfaceWifi( void ){ /* TODO: clean up*/ };
00143   virtual int ProcessMessage(QueuePointer & resp_queue,
00144                              player_msghdr_t* hdr,
00145                              void* data);
00146   virtual void Publish( void );
00147 };
00148 
00149 class InterfaceSpeech : public InterfaceModel
00150 {
00151  public:
00152   InterfaceSpeech( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00153   virtual ~InterfaceSpeech( void ){ /* TODO: clean up*/ };
00154   virtual int ProcessMessage(QueuePointer & resp_queue,
00155                              player_msghdr_t* hdr,
00156                              void* data);
00157   virtual void Publish( void );
00158 };
00159 
00160 /* DEPRECATED */
00161 /* class InterfaceLaser : public InterfaceModel */
00162 /* { */
00163 /*   private: */
00164 /*     int scan_id; */
00165 /*  public: */
00166 /*   InterfaceLaser( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section ); */
00167 /*   virtual ~InterfaceLaser( void ){ /\* TODO: clean up*\/ }; */
00168 /*   virtual int ProcessMessage(QueuePointer & resp_queue, */
00169 /*                player_msghdr_t* hdr, */
00170 /*                void* data); */
00171 /*   virtual void Publish( void ); */
00172 /* }; */
00173 
00174 class InterfaceRanger : public InterfaceModel
00175 {
00176   private:
00177     int scan_id;
00178  public:
00179   InterfaceRanger( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00180   virtual ~InterfaceRanger( void ){ /* TODO: clean up*/ };
00181   virtual int ProcessMessage(QueuePointer & resp_queue,
00182                   player_msghdr_t* hdr,
00183                   void* data);
00184   virtual void Publish( void );
00185 };
00186 
00187 /*  class InterfaceAio : public InterfaceModel */
00188 /* { */
00189 /*  public: */
00190 /*   InterfaceAio( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section ); */
00191 /*   virtual ~InterfaceAio( void ){ /\* TODO: clean up*\/ }; */
00192 /*   virtual int ProcessMessage(QueuePointer & resp_queue, */
00193 /*                player_msghdr_t* hdr, */
00194 /*                void* data); */
00195 /*   virtual void Publish( void ); */
00196 /* }; */
00197 
00198 
00199 /* class InterfaceDio : public InterfaceModel */
00200 /* { */
00201 /* public: */
00202 /*  InterfaceDio(player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section); */
00203 /*  virtual ~InterfaceDio(); */
00204 /*  virtual int ProcessMessage(QueuePointer & resp_queue, player_msghdr_t* hdr, void* data); */
00205 /*  virtual void Publish(); */
00206 /* }; */
00207 
00208 
00209 class InterfacePower : public InterfaceModel
00210 {
00211  public:
00212   InterfacePower( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00213   virtual ~InterfacePower( void ){ /* TODO: clean up*/ };
00214 
00215   virtual int ProcessMessage( QueuePointer & resp_queue,
00216                   player_msghdr * hdr,
00217                   void * data );
00218 
00219   virtual void Publish( void );
00220 };
00221 
00222 class InterfaceFiducial : public InterfaceModel
00223 {
00224  public:
00225   InterfaceFiducial( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00226   virtual ~InterfaceFiducial( void ){ /* TODO: clean up*/ };
00227 
00228   virtual void Publish( void );
00229   virtual int ProcessMessage(QueuePointer & resp_queue,
00230                              player_msghdr_t* hdr,
00231                              void* data);
00232 };
00233 
00234 
00235 class InterfaceActArray : public InterfaceModel
00236 {
00237  public:
00238      InterfaceActArray( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00239   virtual ~InterfaceActArray( void ){ /* TODO: clean up*/ };
00240 
00241   virtual int ProcessMessage( QueuePointer & resp_queue,
00242                   player_msghdr * hdr,
00243                   void * data );
00244   virtual void Publish( void );
00245 };
00246 
00247 class InterfaceBlobfinder : public InterfaceModel
00248 {
00249  public:
00250   InterfaceBlobfinder( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00251   virtual ~InterfaceBlobfinder( void ){ /* TODO: clean up*/ };
00252 
00253   virtual int ProcessMessage( QueuePointer & resp_queue,
00254                   player_msghdr * hdr,
00255                   void * data );
00256   virtual void Publish( void );
00257 };
00258 
00259 class InterfacePtz : public InterfaceModel
00260 {
00261  public:
00262   InterfacePtz( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00263   virtual ~InterfacePtz( void ){ /* TODO: clean up*/ };
00264 
00265   virtual int ProcessMessage( QueuePointer & resp_queue,
00266                   player_msghdr * hdr,
00267                   void * data );
00268   virtual void Publish( void );
00269 };
00270 
00271 /* DEPRECATED */
00272 /* class InterfaceSonar : public InterfaceModel */
00273 /* { */
00274 /*  public: */
00275 /*   InterfaceSonar( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section ); */
00276 /*   virtual ~InterfaceSonar( void ){ /\* TODO: clean up*\/ }; */
00277 
00278 /*   virtual int ProcessMessage( QueuePointer & resp_queue, */
00279 /*                player_msghdr * hdr, */
00280 /*                void * data ); */
00281 /*   virtual void Publish( void ); */
00282 /* }; */
00283 
00284 
00285 class InterfaceBumper : public InterfaceModel
00286 {
00287  public:
00288   InterfaceBumper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00289   virtual ~InterfaceBumper( void ){ /* TODO: clean up*/ };
00290 
00291   virtual int ProcessMessage( QueuePointer & resp_queue,
00292                   player_msghdr * hdr,
00293                   void * data );
00294   virtual void Publish( void );
00295 };
00296 
00297 class InterfaceLocalize : public InterfaceModel
00298 {
00299  public:
00300   InterfaceLocalize( player_devaddr_t addr,
00301              StgDriver* driver,
00302              ConfigFile* cf,
00303              int section );
00304 
00305   virtual ~InterfaceLocalize( void ){ /* TODO: clean up*/ };
00306 
00307   virtual void Publish( void );
00308   virtual int ProcessMessage(QueuePointer & resp_queue,
00309                              player_msghdr_t* hdr,
00310                              void* data);
00311 };
00312 
00313 class InterfaceMap : public InterfaceModel
00314 {
00315  public:
00316   InterfaceMap( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00317   virtual ~InterfaceMap( void ){ /* TODO: clean up*/ };
00318 
00319   virtual int ProcessMessage( QueuePointer & resp_queue,
00320                   player_msghdr * hdr,
00321                   void * data );
00322   //virtual void Publish( void );
00323 
00324   // called by ProcessMessage to handle individual messages
00325 
00326   int HandleMsgReqInfo( QueuePointer & resp_queue,
00327             player_msghdr * hdr,
00328             void * data );
00329   int HandleMsgReqData( QueuePointer & resp_queue,
00330             player_msghdr * hdr,
00331             void * data );
00332 };
00333 
00334 class PlayerGraphics2dVis;
00335 class InterfaceGraphics2d : public InterfaceModel
00336 {
00337  public:
00338   InterfaceGraphics2d( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00339   virtual ~InterfaceGraphics2d( void );
00340 
00341   void Subscribe(QueuePointer &queue);
00342   void Unsubscribe(QueuePointer &queue);
00343 
00344   virtual int ProcessMessage( QueuePointer & resp_queue,
00345                   player_msghdr * hdr,
00346                   void * data );
00347 
00348   PlayerGraphics2dVis * vis;
00349 };
00350 
00351 class PlayerGraphics3dVis;
00352 class InterfaceGraphics3d : public InterfaceModel
00353 {
00354  public:
00355   InterfaceGraphics3d( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00356   virtual ~InterfaceGraphics3d( void );
00357 
00358   void Subscribe(QueuePointer &queue);
00359   void Unsubscribe(QueuePointer &queue);
00360 
00361   virtual int ProcessMessage( QueuePointer & resp_queue,
00362                   player_msghdr * hdr,
00363                   void * data );
00364 
00365   PlayerGraphics3dVis * vis;
00366 };
00367 
00369 class StTime : public PlayerTime
00370 {
00371  private:
00372   StgDriver* driver;
00373 
00374  public:
00375  // Constructor
00376   StTime( StgDriver* driver );
00377 
00378  // Destructor
00379  virtual ~StTime();
00380 
00381  // Get the simulator time
00382  int GetTime(struct timeval* time);
00383  int GetTimeDouble(double* time);
00384 };
00385 
00386 
00387 #endif