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   //GPtrArray* devices;
00055     std::vector<Interface*> devices;
00056 };
00057 
00058 
00059 class Interface
00060 {
00061  public:
00062   Interface(player_devaddr_t addr,
00063             StgDriver* driver,
00064             ConfigFile* cf,
00065             int section );
00066 
00067   virtual ~Interface( void ){ /* TODO: clean up*/ };
00068 
00069   player_devaddr_t addr;
00070   double last_publish_time;
00071   double publish_interval_msec;
00072 
00073   StgDriver* driver; // the driver instance that created this device
00074 
00075   virtual int ProcessMessage(QueuePointer &resp_queue,
00076                      player_msghdr_t* hdr,
00077                  void* data) { return(-1); } // empty implementation
00078 
00079   virtual void Publish( void ){}; // do nothing
00080   virtual void Subscribe( void ){}; // do nothing
00081   virtual void Unsubscribe( void ){}; // do nothing
00082   virtual void Subscribe( QueuePointer &queue ){}; // do nothing
00083   virtual void Unsubscribe( QueuePointer &queue ){}; // do nothing};
00084 };
00085 
00086 class InterfaceSimulation : public Interface
00087 {
00088  public:
00089   InterfaceSimulation( player_devaddr_t addr,  StgDriver* driver,ConfigFile* cf, int section );
00090   virtual ~InterfaceSimulation( void ){ /* TODO: clean up*/ };
00091   virtual int ProcessMessage(QueuePointer & resp_queue,
00092                              player_msghdr_t* hdr,
00093                              void* data);
00094 };
00095 
00096 // base class for all interfaces that are associated with a model
00097 class InterfaceModel
00098 
00099  : public Interface
00100 {
00101  public:
00102   InterfaceModel( player_devaddr_t addr,
00103           StgDriver* driver,
00104           ConfigFile* cf,
00105           int section,
00106           const std::string& type );
00107 
00108   virtual ~InterfaceModel( void ){ Unsubscribe(); };
00109 
00110   virtual void Subscribe( void );
00111   virtual void Unsubscribe( void );
00112 
00113  protected:
00114   Stg::Model* mod;
00115 
00116  private:
00117   bool subscribed;
00118 };
00119 
00120 
00121 class InterfacePosition : public InterfaceModel
00122 {
00123  public:
00124   InterfacePosition( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00125   virtual ~InterfacePosition( void ){ /* TODO: clean up*/ };
00126   virtual void Publish( void );
00127   virtual int ProcessMessage(QueuePointer & resp_queue,
00128                              player_msghdr_t* hdr,
00129                              void* data);
00130 };
00131 
00132 class InterfaceGripper : public InterfaceModel
00133 {
00134  public:
00135   InterfaceGripper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00136   virtual ~InterfaceGripper( void ){ /* TODO: clean up*/ };
00137   virtual int ProcessMessage(QueuePointer & resp_queue,
00138                              player_msghdr_t* hdr,
00139                              void* data);
00140   virtual void Publish( void );
00141 };
00142 
00143 class InterfaceWifi : public InterfaceModel
00144 {
00145  public:
00146   InterfaceWifi( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00147   virtual ~InterfaceWifi( void ){ /* TODO: clean up*/ };
00148   virtual int ProcessMessage(QueuePointer & resp_queue,
00149                              player_msghdr_t* hdr,
00150                              void* data);
00151   virtual void Publish( void );
00152 };
00153 
00154 class InterfaceSpeech : public InterfaceModel
00155 {
00156  public:
00157   InterfaceSpeech( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00158   virtual ~InterfaceSpeech( void ){ /* TODO: clean up*/ };
00159   virtual int ProcessMessage(QueuePointer & resp_queue,
00160                              player_msghdr_t* hdr,
00161                              void* data);
00162   virtual void Publish( void );
00163 };
00164 
00165 class InterfaceLaser : public InterfaceModel
00166 {
00167   private:
00168     int scan_id;
00169  public:
00170   InterfaceLaser( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00171   virtual ~InterfaceLaser( void ){ /* TODO: clean up*/ };
00172   virtual int ProcessMessage(QueuePointer & resp_queue,
00173                   player_msghdr_t* hdr,
00174                   void* data);
00175   virtual void Publish( void );
00176 };
00177 
00178 /*  class InterfaceAio : public InterfaceModel */
00179 /* { */
00180 /*  public: */
00181 /*   InterfaceAio( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section ); */
00182 /*   virtual ~InterfaceAio( void ){ /\* TODO: clean up*\/ }; */
00183 /*   virtual int ProcessMessage(QueuePointer & resp_queue, */
00184 /*                player_msghdr_t* hdr, */
00185 /*                void* data); */
00186 /*   virtual void Publish( void ); */
00187 /* }; */
00188 
00189 
00190 /* class InterfaceDio : public InterfaceModel */
00191 /* { */
00192 /* public: */
00193 /*  InterfaceDio(player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section); */
00194 /*  virtual ~InterfaceDio(); */
00195 /*  virtual int ProcessMessage(QueuePointer & resp_queue, player_msghdr_t* hdr, void* data); */
00196 /*  virtual void Publish(); */
00197 /* }; */
00198 
00199 
00200 class InterfacePower : public InterfaceModel
00201 {
00202  public:
00203   InterfacePower( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00204   virtual ~InterfacePower( void ){ /* TODO: clean up*/ };
00205 
00206   virtual int ProcessMessage( QueuePointer & resp_queue,
00207                   player_msghdr * hdr,
00208                   void * data );
00209 
00210   virtual void Publish( void );
00211 };
00212 
00213 class InterfaceFiducial : public InterfaceModel
00214 {
00215  public:
00216   InterfaceFiducial( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00217   virtual ~InterfaceFiducial( void ){ /* TODO: clean up*/ };
00218 
00219   virtual void Publish( void );
00220   virtual int ProcessMessage(QueuePointer & resp_queue,
00221                              player_msghdr_t* hdr,
00222                              void* data);
00223 };
00224 
00225 
00226 class InterfaceActArray : public InterfaceModel
00227 {
00228  public:
00229      InterfaceActArray( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00230   virtual ~InterfaceActArray( void ){ /* TODO: clean up*/ };
00231 
00232   virtual int ProcessMessage( QueuePointer & resp_queue,
00233                   player_msghdr * hdr,
00234                   void * data );
00235   virtual void Publish( void );
00236 };
00237 
00238 class InterfaceBlobfinder : public InterfaceModel
00239 {
00240  public:
00241   InterfaceBlobfinder( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00242   virtual ~InterfaceBlobfinder( void ){ /* TODO: clean up*/ };
00243 
00244   virtual int ProcessMessage( QueuePointer & resp_queue,
00245                   player_msghdr * hdr,
00246                   void * data );
00247   virtual void Publish( void );
00248 };
00249 
00250 class InterfacePtz : public InterfaceModel
00251 {
00252  public:
00253   InterfacePtz( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00254   virtual ~InterfacePtz( void ){ /* TODO: clean up*/ };
00255 
00256   virtual int ProcessMessage( QueuePointer & resp_queue,
00257                   player_msghdr * hdr,
00258                   void * data );
00259   virtual void Publish( void );
00260 };
00261 
00262 class InterfaceSonar : public InterfaceModel
00263 {
00264  public:
00265   InterfaceSonar( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00266   virtual ~InterfaceSonar( void ){ /* TODO: clean up*/ };
00267 
00268   virtual int ProcessMessage( QueuePointer & resp_queue,
00269                   player_msghdr * hdr,
00270                   void * data );
00271   virtual void Publish( void );
00272 };
00273 
00274 
00275 class InterfaceBumper : public InterfaceModel
00276 {
00277  public:
00278   InterfaceBumper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00279   virtual ~InterfaceBumper( void ){ /* TODO: clean up*/ };
00280 
00281   virtual int ProcessMessage( QueuePointer & resp_queue,
00282                   player_msghdr * hdr,
00283                   void * data );
00284   virtual void Publish( void );
00285 };
00286 
00287 class InterfaceLocalize : public InterfaceModel
00288 {
00289  public:
00290   InterfaceLocalize( player_devaddr_t addr,
00291              StgDriver* driver,
00292              ConfigFile* cf,
00293              int section );
00294 
00295   virtual ~InterfaceLocalize( void ){ /* TODO: clean up*/ };
00296 
00297   virtual void Publish( void );
00298   virtual int ProcessMessage(QueuePointer & resp_queue,
00299                              player_msghdr_t* hdr,
00300                              void* data);
00301 };
00302 
00303 class InterfaceMap : public InterfaceModel
00304 {
00305  public:
00306   InterfaceMap( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00307   virtual ~InterfaceMap( void ){ /* TODO: clean up*/ };
00308 
00309   virtual int ProcessMessage( QueuePointer & resp_queue,
00310                   player_msghdr * hdr,
00311                   void * data );
00312   //virtual void Publish( void );
00313 
00314   // called by ProcessMessage to handle individual messages
00315 
00316   int HandleMsgReqInfo( QueuePointer & resp_queue,
00317             player_msghdr * hdr,
00318             void * data );
00319   int HandleMsgReqData( QueuePointer & resp_queue,
00320             player_msghdr * hdr,
00321             void * data );
00322 };
00323 
00324 class PlayerGraphics2dVis;
00325 class InterfaceGraphics2d : public InterfaceModel
00326 {
00327  public:
00328   InterfaceGraphics2d( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00329   virtual ~InterfaceGraphics2d( void );
00330 
00331   void Subscribe(QueuePointer &queue);
00332   void Unsubscribe(QueuePointer &queue);
00333 
00334   virtual int ProcessMessage( QueuePointer & resp_queue,
00335                   player_msghdr * hdr,
00336                   void * data );
00337 
00338   PlayerGraphics2dVis * vis;
00339 };
00340 
00341 class PlayerGraphics3dVis;
00342 class InterfaceGraphics3d : public InterfaceModel
00343 {
00344  public:
00345   InterfaceGraphics3d( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00346   virtual ~InterfaceGraphics3d( void );
00347 
00348   void Subscribe(QueuePointer &queue);
00349   void Unsubscribe(QueuePointer &queue);
00350 
00351   virtual int ProcessMessage( QueuePointer & resp_queue,
00352                   player_msghdr * hdr,
00353                   void * data );
00354 
00355   PlayerGraphics3dVis * vis;
00356 };
00357 
00359 class StTime : public PlayerTime
00360 {
00361  private:
00362   StgDriver* driver;
00363 
00364  public:
00365  // Constructor
00366   StTime( StgDriver* driver );
00367 
00368  // Destructor
00369  virtual ~StTime();
00370 
00371  // Get the simulator time
00372  int GetTime(struct timeval* time);
00373  int GetTimeDouble(double* time);
00374 };
00375 
00376 
00377 #endif