Home FAQ Player Stage Gazebo Contrib Documentation Publications Contributors Users Project Download Bugs/Feedback Mailing lists Radish Old news Old stuff

driver.h Go to the documentation of this file. /* * 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 * */ /* * $Id: driver.h,v 1.10 2004/11/12 20:02:13 gerkey Exp $ * * 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 <stddef.h> /* for size_t */ #include "playercommon.h" #include "playerqueue.h" extern bool debug; extern bool experimental; // Forward declarations class CLock; class ConfigFile; class Driver { private: // this mutex is used to lock data, command, and req/rep buffers/queues // TODO: could implement different mutexes for each data structure, but // is it worth it? // // NOTE: StageDevice won't use this; it declares its own inter-process // locking mechanism (and overrides locking methods) pthread_mutex_t accessMutex; // the driver's thread pthread_t driverthread; // A condition variable (and accompanying mutex) that can be used to // signal other drivers that are waiting on this one. pthread_cond_t cond; pthread_mutex_t condMutex; public: player_device_id_t device_id; int subscriptions; int entries; bool alwayson; int error; public: // Driver(ConfigFile *cf, int section, int interface, uint8_t access, size_t datasize, size_t commandsize, size_t reqqueuelen, size_t repqueuelen); Driver(ConfigFile *cf, int section); virtual ~Driver(); int AddInterface(player_device_id_t id, unsigned char access, size_t datasize, size_t commandsize, size_t reqqueuelen, size_t repqueuelen); int AddInterface(player_device_id_t id, unsigned char access, void* data, size_t datasize, void* command, size_t commandsize, void* reqqueue, int reqqueuelen, void* repqueue, int repqueuelen); void SetError(int code) {this->error = code;} virtual int Subscribe(player_device_id_t id); virtual int Unsubscribe(player_device_id_t id); virtual int Setup() = 0; virtual int Shutdown() = 0; virtual void Prepare() {} public: void StartThread(void); void StopThread(void); virtual void Main(void); virtual void MainQuit(void); private: // Dummy main (just calls real main). This is used to simplify // thread creation. static void* DummyMain(void *driver); // Dummy main cleanup (just calls real main cleanup). This is // used to simplify thread termination. static void DummyMainQuit(void *driver); public: void Wait(void); void DataAvailable(void); // a static version of DataAvailable that can be used as a // callback from libraries. It calls driver->DataAvailable(). static void DataAvailableStatic( Driver* driver ); virtual void Update() {} // Note: the Get* and Put* functions MAY be overridden by the // driver itself, but then the driver is reponsible for Lock()ing // and Unlock()ing appropriately virtual void PutData(player_device_id_t id, void* src, size_t len, struct timeval* timestamp); void PutData(void* src, size_t len, struct timeval* timestamp) { PutData(this->device_id,src,len,timestamp); } virtual size_t GetData(player_device_id_t id, void* dest, size_t len, struct timeval* timestamp); virtual void PutCommand(player_device_id_t id, void* src, size_t len, struct timeval* timestamp); virtual size_t GetCommand(player_device_id_t id, void* dest, size_t len, struct timeval* timestamp); size_t GetCommand(void* dest, size_t len, struct timeval* timestamp) { return GetCommand(this->device_id,dest,len,timestamp); } virtual void ClearCommand(player_device_id_t id); void ClearCommand(void) { ClearCommand(this->device_id); } virtual int PutConfig(player_device_id_t id, void *client, void* src, size_t len, struct timeval* timestamp); virtual int GetConfig(player_device_id_t id, void **client, void* dest, size_t len, struct timeval* timestamp); int GetConfig(void** client, void* dest, size_t len, struct timeval* timestamp) { return GetConfig(this->device_id,client,dest,len,timestamp); } virtual int PutReply(player_device_id_t id, void* client, unsigned short type, void* src, size_t len, struct timeval* timestamp); int PutReply(void* client, unsigned short type, void* src, size_t len, struct timeval* timestamp) { return PutReply(this->device_id,client,type,src,len,timestamp); } int PutReply(player_device_id_t id, void* client, unsigned short type, struct timeval* timestamp) { return PutReply(id,client,type,NULL,0,timestamp); } int PutReply(void* client, unsigned short type, struct timeval* timestamp) { return PutReply(this->device_id,client,type,NULL,0,timestamp); } virtual int GetReply(player_device_id_t id, void* client, unsigned short* type, void* dest, size_t len, struct timeval* timestamp); virtual int Request(player_device_id_t id, void* requester, void* request, size_t reqlen, struct timeval* req_timestamp, unsigned short* reptype, void* reply, size_t replen, struct timeval* rep_timestamp); protected: // these methods are used to lock and unlock the various buffers and // queues; they are implemented with mutexes in Driver and overridden // in CStageDriver virtual void Lock(void); virtual void Unlock(void); }; #endif