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 "stage_internal.h"
00011 #include "stg_time.h"
00012 
00013 #define DRIVER_ERROR(X) printf( "Stage driver error: %s\n", X )
00014 
00015 // foward declare;
00016 class Interface;
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_t* world;
00042   
00044   Interface* LookupDevice( player_devaddr_t addr );
00045   
00046   stg_model_t* LocateModel( char* basename, 
00047                             player_devaddr_t* addr,
00048                             stg_model_initializer_t init );
00049   
00050  protected: 
00051   
00053   GPtrArray* devices;  
00054 
00055   static unsigned int instance_count;
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   stg_model_t* mod;
00071   double last_publish_time;
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   virtual void Publish( void ){}; // empty implementation
00079   
00080   virtual int Subscribe(QueuePointer &queue, player_devaddr_t addr) { return 0; }
00081   virtual int Unsubscribe(QueuePointer &queue, player_devaddr_t addr) { return 0; }
00082 };
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 
00096 class InterfaceModel : public Interface
00097 {
00098  public: 
00099   InterfaceModel( player_devaddr_t addr,  
00100                   StgDriver* driver,
00101                   ConfigFile* cf, 
00102                   int section, 
00103                   stg_model_initializer_t init );
00104   
00105   virtual ~InterfaceModel( void ){ /* TODO: clean up*/ };
00106 };
00107 
00108 class InterfacePosition : public InterfaceModel
00109 {
00110  private:
00111   bool stopped;
00112   int last_cmd_time;
00113  public: 
00114   InterfacePosition( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00115   virtual ~InterfacePosition( void ){ /* TODO: clean up*/ };
00116   virtual void Publish( void );
00117   virtual int ProcessMessage(QueuePointer &resp_queue,
00118                              player_msghdr_t* hdr,
00119                              void* data);
00120 };
00121  
00122 class InterfaceGripper : public InterfaceModel
00123 {
00124  public: 
00125   InterfaceGripper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00126   virtual ~InterfaceGripper( void ){ /* TODO: clean up*/ };
00127   virtual int ProcessMessage(QueuePointer &resp_queue,
00128                              player_msghdr_t* hdr,
00129                              void* data);
00130   virtual void Publish( void );
00131 };
00132 
00133 class InterfaceWifi : public InterfaceModel
00134 {
00135  public: 
00136   InterfaceWifi( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00137   virtual ~InterfaceWifi( void ){ /* TODO: clean up*/ };
00138   virtual int ProcessMessage(QueuePointer &resp_queue,
00139                              player_msghdr_t* hdr,
00140                              void* data);
00141   virtual void Publish( void );
00142 };
00143 
00144 class InterfaceSpeech : public InterfaceModel
00145 {
00146  public: 
00147   InterfaceSpeech( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00148   virtual ~InterfaceSpeech( void ){ /* TODO: clean up*/ };
00149   virtual int ProcessMessage(QueuePointer &resp_queue,
00150                              player_msghdr_t* hdr,
00151                              void* data);
00152   virtual void Publish( void );
00153 };
00154 
00155 class InterfaceAudio : public InterfaceModel
00156 {
00157  public: 
00158   InterfaceAudio( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00159   virtual ~InterfaceAudio( void ){ /* TODO: clean up*/ };
00160   virtual int ProcessMessage(QueuePointer &resp_queue,
00161                              player_msghdr_t* hdr,
00162                              void* data);
00163   virtual void Publish( void );
00164 };
00165 
00166 class InterfaceLaser : public InterfaceModel
00167 {
00168   private:
00169     int scan_id;
00170  public: 
00171   InterfaceLaser( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00172   virtual ~InterfaceLaser( void ){ /* TODO: clean up*/ };
00173   virtual int ProcessMessage(QueuePointer &resp_queue,
00174                               player_msghdr_t* hdr,
00175                               void* data);
00176   virtual void Publish( void );
00177 };
00178 
00179 /*
00180 class InterfacePower : public InterfaceModel
00181 {
00182  public: 
00183   InterfacePower( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00184   virtual ~InterfacePower( void ){ /* TODO: clean up* };
00185   
00186   virtual int ProcessMessage( QueuePointer &resp_queue, 
00187                               player_msghdr * hdr, 
00188                               void * data );
00189   
00190   virtual void Publish( void );
00191 };
00192 */
00193 
00194 class InterfaceFiducial : public InterfaceModel
00195 {
00196  public: 
00197   InterfaceFiducial( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00198   virtual ~InterfaceFiducial( void ){ /* TODO: clean up*/ };
00199 
00200   virtual void Publish( void );
00201   virtual int ProcessMessage(QueuePointer &resp_queue,
00202                              player_msghdr_t* hdr,
00203                              void* data);
00204 };
00205 
00206  
00207 class InterfaceBlobfinder : public InterfaceModel
00208 {
00209  public: 
00210   InterfaceBlobfinder( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00211   virtual ~InterfaceBlobfinder( void ){ /* TODO: clean up*/ };
00212   
00213   virtual int ProcessMessage( QueuePointer &resp_queue, 
00214                               player_msghdr * hdr, 
00215                               void * data );
00216   virtual void Publish( void );
00217 };
00218 
00219 class InterfacePtz : public InterfaceModel
00220 {
00221  public: 
00222   InterfacePtz( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00223   virtual ~InterfacePtz( void ){ /* TODO: clean up*/ };
00224   
00225   virtual int ProcessMessage( QueuePointer &resp_queue, 
00226                               player_msghdr * hdr, 
00227                               void * data );
00228   virtual void Publish( void );
00229 };
00230 
00231 class InterfaceSonar : public InterfaceModel
00232 {
00233  public: 
00234   InterfaceSonar( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00235   virtual ~InterfaceSonar( void ){ /* TODO: clean up*/ };
00236   
00237   virtual int ProcessMessage( QueuePointer &resp_queue, 
00238                               player_msghdr * hdr, 
00239                               void * data );
00240   virtual void Publish( void );
00241 };
00242  
00243 
00244 class InterfaceBumper : public InterfaceModel
00245 {
00246  public: 
00247   InterfaceBumper( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00248   virtual ~InterfaceBumper( void ){ /* TODO: clean up*/ };
00249   
00250   virtual int ProcessMessage( QueuePointer &resp_queue, 
00251                               player_msghdr * hdr, 
00252                               void * data );
00253   virtual void Publish( void );
00254 };
00255  
00256 class InterfaceLocalize : public InterfaceModel
00257 {
00258  public: 
00259   InterfaceLocalize( player_devaddr_t addr, 
00260                      StgDriver* driver, 
00261                      ConfigFile* cf, 
00262                      int section );
00263 
00264   virtual ~InterfaceLocalize( void ){ /* TODO: clean up*/ };
00265 
00266   virtual void Publish( void );
00267   virtual int ProcessMessage(QueuePointer &resp_queue,
00268                              player_msghdr_t* hdr,
00269                              void* data);
00270 };
00271 
00272 class InterfaceMap : public InterfaceModel
00273 {
00274  public: 
00275   InterfaceMap( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00276   virtual ~InterfaceMap( 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   // called by ProcessMessage to handle individual messages
00284 
00285   int HandleMsgReqInfo( QueuePointer &resp_queue, 
00286                         player_msghdr * hdr, 
00287                         void * data );
00288   int HandleMsgReqData( QueuePointer &resp_queue, 
00289                         player_msghdr * hdr, 
00290                         void * data );
00291 };
00292 
00293 #define INTERFACE_GRAPHICS_2D_MAX_CLIENTS 16
00294 
00295 struct Graphics2dFig
00296 {
00297         QueuePointer queue;
00298         stg_rtk_fig_t* stageFig;
00299 };
00300 
00301 class InterfaceGraphics2d : public InterfaceModel
00302 {
00303  public: 
00304   InterfaceGraphics2d( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00305   virtual ~InterfaceGraphics2d( void );
00306   
00307   virtual int ProcessMessage( QueuePointer &resp_queue, 
00308                               player_msghdr * hdr, 
00309                               void * data );
00310   
00311   // Override subscribe and unsubscribe to handle each client separately.
00312   virtual int Subscribe(QueuePointer &queue, player_devaddr_t addr);
00313   virtual int Unsubscribe(QueuePointer &queue, player_devaddr_t addr);
00314  private:
00315   Graphics2dFig figs[INTERFACE_GRAPHICS_2D_MAX_CLIENTS]; // a figure we can draw in
00316 };
00317 
00318 
00319 class InterfaceDio : public InterfaceModel
00320 {
00321  public: 
00322          InterfaceDio( player_devaddr_t addr, StgDriver* driver, ConfigFile* cf, int section );
00323   virtual ~InterfaceDio( void ){ /* TODO: clean up*/ };
00324   
00325   virtual int ProcessMessage( QueuePointer &resp_queue, 
00326                               player_msghdr * hdr, 
00327                               void * data );
00328   
00329   virtual void Publish( void );
00330 };
00331 
00332 
00333 #endif

Generated on Wed Jun 3 23:12:28 2009 for Stage by  doxygen 1.5.9