Player

• Frontpage
• Contents

User

• Installation
• Quick start
• Supported devices
• Tutorials
• Utilities
• Client libraries
• FAQ
• Help

Developer

• Architecture
• libplayercore
  • interfaces
• libplayerdrivers
  • drivers
• libplayererror
• libplayerutils
• libplayersd
• libplayertcp
• libplayerxdr
• TODO

Online

Homepage
Download
Project
Bugs
Help

driver.h

/*
 *  Player - One Hell of a Robot Server
 *  Copyright (C) 2000
 *     Brian Gerkey, Kasper Stoy, Richard Vaughan, & 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
 *
 */
/********************************************************************
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 ********************************************************************/

/*
 * $Id: driver.h 6566 2008-06-14 01:00:19Z thjc $
 *
 *  The virtual class from which all driver classes inherit.  this
 *  defines the API that all drivers must implement.
 */

#ifndef _DRIVER_H
#define _DRIVER_H

#include <pthread.h>

#include <libplayercore/playercommon.h>
#include <libplayercore/message.h>
#include <libplayercore/player.h>
#include <libplayercore/property.h>

using namespace std;

#define HANDLE_CAPABILITY_REQUEST(device_addr, queue, hdr, data, cap_type, cap_subtype) \
  if(Message::MatchMessage(hdr, PLAYER_MSGTYPE_REQ, PLAYER_CAPABILTIES_REQ, device_addr)) \
  { \
    player_capabilities_req_t & cap_req = * reinterpret_cast<player_capabilities_req_t *> (data);\
    if (cap_req.type == cap_type && cap_req.subtype == cap_subtype) \
    { \
      Publish(device_addr, queue, PLAYER_MSGTYPE_RESP_ACK, PLAYER_CAPABILTIES_REQ); \
      return 0; \
    } \
  }


// Forward declarations
class ConfigFile;

class Driver
{
  private:
    pthread_mutex_t accessMutex;

    /* @brief Last error value; useful for returning error codes from
    constructors. */
    int error;

    PropertyBag propertyBag;

  protected:

    /* @brief Start the driver thread

    This method is usually called from the overloaded Setup() method to
    create the driver thread.  This will call Main(). */
    virtual void StartThread(void);

    virtual void StopThread(void);

    static void* DummyMain(void *driver);

    static void DummyMainQuit(void *driver);

    int AddInterface(player_devaddr_t addr);

    int AddInterface(player_devaddr_t *addr, ConfigFile * cf, int section, int code, char * key = NULL);


    void SetError(int code) {this->error = code;}

    bool Wait(double TimeOut=0.0) { return this->InQueue->Wait(TimeOut); }

    int AddFileWatch(int fd, bool ReadWatch = true, bool WriteWatch = false, bool ExceptWatch = true);

    int RemoveFileWatch(int fd, bool ReadWatch = true, bool WriteWatch = false, bool ExceptWatch = true);


  public:
    pthread_t driverthread;
    virtual void Lock(void);
    virtual void Unlock(void);

    QueuePointer ret_queue;

    virtual void Publish(player_devaddr_t addr,
                 QueuePointer &queue,
                 uint8_t type,
                 uint8_t subtype,
                 void* src=NULL,
                 size_t deprecated=0,
                 double* timestamp=NULL,
                 bool copy=true);

     virtual void Publish(player_devaddr_t addr,
                  uint8_t type,
                  uint8_t subtype,
                  void* src=NULL,
                  size_t deprecated=0,
                  double* timestamp=NULL,
                  bool copy=true);



    virtual void Publish(QueuePointer &queue,
                 player_msghdr_t* hdr,
                 void* src,
                 bool copy = true);

    virtual void Publish(player_msghdr_t* hdr,
                 void* src,
                 bool copy = true);


    player_devaddr_t device_addr;

    int subscriptions;

    int entries;

    bool alwayson;

    QueuePointer InQueue;

    Driver(ConfigFile *cf,
           int section,
           bool overwrite_cmds,
           size_t queue_maxlen,
           int interf);

    Driver(ConfigFile *cf,
           int section,
           bool overwrite_cmds = true,
           size_t queue_maxlen = PLAYER_MSGQUEUE_DEFAULT_MAXLEN);

    virtual ~Driver();

    int GetError() { return(this->error); }

    virtual int Subscribe(player_devaddr_t addr);

    virtual int Subscribe(QueuePointer &queue, player_devaddr_t addr) {return 1;};

    virtual int Unsubscribe(player_devaddr_t addr);

    virtual int Unsubscribe(QueuePointer &queue, player_devaddr_t addr) {return 1;};

    virtual int Setup() = 0;

    virtual int Shutdown() = 0;

    virtual void Main(void);

    virtual void MainQuit(void);

    void ProcessMessages(int maxmsgs);

    void ProcessMessages(void);

    virtual int ProcessMessage(QueuePointer &resp_queue, player_msghdr * hdr,
                               void * data);

    virtual void Update()
    {
      if(!this->driverthread)
        this->ProcessMessages();
    }

    virtual int ProcessInternalMessages(QueuePointer& resp_queue,
                                        player_msghdr * hdr,
                                        void * data);

    virtual bool RegisterProperty(const char *key, Property *prop, ConfigFile* cf, int section);

    virtual bool RegisterProperty(Property *prop, ConfigFile* cf, int section);
};


#endif

---

Last updated 12 September 2005 21:38:45