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

playerclient.h Go to the documentation of this file. /* * Player - One Hell of a Robot Server * Copyright (C) 2000-2003 * 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 * */ /* * Player - One Hell of a Robot Server * Copyright (C) 2003 * Brian Gerkey, Kasper Stoy, Richard Vaughan, & Andrew Howard * * * 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: playerclient.h,v 1.150 2005/05/03 00:23:59 gerkey Exp $ * * the C++ client */ #ifndef PLAYERCLIENT_H #define PLAYERCLIENT_H #include <player.h> /* from the server; gives message types */ #include <playercclient.h> /* pure C networking building blocks */ #if HAVE_STRINGS_H #include <strings.h> #endif #if PLAYERCLIENT_THREAD #include <pthread.h> #endif #include <sys/time.h> struct pollfd; #include <string.h> #include <math.h> #ifndef RTOD #define RTOD(r) ((r) * 180 / M_PI) #endif #ifndef DTOR #define DTOR(d) ((d) * M_PI / 180) #endif #ifndef NORMALIZE #define NORMALIZE(z) atan2(sin(z), cos(z)) #endif // forward declaration for friending class PlayerClient; class ClientProxy { friend class PlayerClient; // ANSI C++ syntax? public: PlayerClient* client; bool valid; bool fresh; // functionality currently disabled, until it is fixed to handle // big messages. #if 0 unsigned char last_data[PLAYER_MAX_MESSAGE_SIZE]; player_msghdr_t last_header; #endif unsigned char access; // 'r', 'w', or 'a' (others?) player_device_id_t m_device_id; char driver_name[PLAYER_MAX_DEVICE_STRING_LEN]; // driver in use struct timeval timestamp; struct timeval senttime; struct timeval receivedtime; ClientProxy(PlayerClient* pc, unsigned short req_device, unsigned short req_index, unsigned char req_access = 'c'); // destructor will try to close access to the device virtual ~ClientProxy(); unsigned char GetAccess() { return(access); }; int ChangeAccess(unsigned char req_access, unsigned char* grant_access=NULL ); int Close() { return(ChangeAccess('c')); } virtual void FillData(player_msghdr_t hdr, const char* buffer); // functionality currently disabled, until it is fixed to handle // big messages. #if 0 void StoreData(player_msghdr_t hdr, const char* buffer); #endif virtual void Print(); int Lock(); int Unlock(); protected: #ifdef PLAYERCLIENT_THREAD pthread_mutex_t update_lock; #endif }; class ClientProxyNode { public: ClientProxy* proxy; ClientProxyNode* next; }; class PlayerClient { private: // special flag to indicate that we are being destroyed bool destroyed; // list of proxies associated with us ClientProxyNode* proxies; int num_proxies; int reserved; unsigned char data_delivery_mode; // get the pointer to the proxy for the given device and index // // returns NULL if we can't find it. // ClientProxy* GetProxy(unsigned short device, unsigned short index); ClientProxy* GetProxy(player_device_id_t id); public: // Struct containing information about the connection to Player player_connection_t conn; // are we connected? bool connected; //void SetReserved(int res) { reserved = res; } //int GetReserved() { return(reserved); } bool fresh; char hostname[256]; int port; // store the IP of the host, too - more efficient for // matching, etc, then the string struct in_addr hostaddr; struct timeval timestamp; int id_count; player_device_id_t ids[PLAYER_MAX_DEVICES]; char drivernames[PLAYER_MAX_DEVICES][PLAYER_MAX_DEVICE_STRING_LEN]; // constructors PlayerClient(const char* hostname=NULL, const int port=PLAYER_PORTNUM, const int protocol=PLAYER_TRANSPORT_TCP); PlayerClient(const struct in_addr* hostaddr, const int port, const int protocol=PLAYER_TRANSPORT_TCP); // destructor ~PlayerClient(); int Connect(const char* hostname="localhost", int port=PLAYER_PORTNUM); int Connect(const struct in_addr* addr, int port); int ConnectRNS(const char* robotname, const char* hostname="localhost", int port=PLAYER_PORTNUM); int Disconnect(); bool Connected() { return((conn.sock >= 0) ? true : false); } int Peek(int timeout=0); int Read(bool await_sync=true, ClientProxy** dev=NULL); int Write(player_device_id_t device_id, const char* command, size_t commandlen); int Request(player_device_id_t device_id, const char* payload, size_t payloadlen, player_msghdr_t* replyhdr, char* reply, size_t replylen); int Request(player_device_id_t device_id, const char* payload, size_t payloadlen); int RequestDeviceAccess(player_device_id_t device_id, unsigned char req_access, unsigned char* grant_access, char* driver_name = NULL, int driver_name_len = 0); // Player device configurations int SetFrequency(unsigned short freq); int SetDataMode(unsigned char mode); int RequestData(); int Authenticate(char* key); int LookupPort(const char* name); // proxy list management methods // add a proxy to the list void AddProxy(ClientProxy* proxy); // remove a proxy from the list void RemoveProxy(ClientProxy* proxy); // Get the list of available device ids. The data is written into the // proxy structure rather than retured to the caller. int GetDeviceList(); }; // forward declaration to avoid including <sys/poll.h>, which may not be // available when people are building clients against this lib struct pollfd; class PlayerMultiClient { private: // dynamically managed array of our clients PlayerClient** clients; //int num_clients; int size_clients; // dynamically managed array of structs that we'll give to poll(2) struct pollfd* ufds; int size_ufds; int num_ufds; public: PlayerMultiClient(); // destructor ~PlayerMultiClient(); int GetNumClients(void) { return num_ufds; }; PlayerClient* GetClient( char* host, int port ); PlayerClient* GetClient( struct in_addr* addr, int port ); void AddClient(PlayerClient* client); void RemoveClient(PlayerClient* client); int Read(); int ReadLatest( int max_reads ); }; class AIOProxy : public ClientProxy { public: AIOProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_AIO_CODE,index,access) {} ~AIOProxy() {} char count; int anin[PLAYER_AIO_MAX_SAMPLES]; // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); }; class GpsProxy : public ClientProxy { public: double latitude; double longitude; double altitude; int satellites; int quality; double hdop; double vdop; double utm_easting; double utm_northing; struct timeval time; GpsProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_GPS_CODE,index,access) {} // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; /* Gripper stuff */ #define GRIPopen 1 #define GRIPclose 2 #define GRIPstop 3 #define LIFTup 4 #define LIFTdown 5 #define LIFTstop 6 #define GRIPstore 7 #define GRIPdeploy 8 #define GRIPhalt 15 #define GRIPpress 16 #define LIFTcarry 17 class GripperProxy : public ClientProxy { public: unsigned char state,beams; bool outer_break_beam,inner_break_beam, paddles_open,paddles_closed,paddles_moving, gripper_error,lift_up,lift_down,lift_moving, lift_error; GripperProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_GRIPPER_CODE,index,access) {} // these methods are the user's interface to this device int SetGrip(unsigned char cmd, unsigned char arg=0); // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class SoundProxy : public ClientProxy { public: SoundProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_SOUND_CODE,index,access) {} // these methods are the user's interface to this device int Play(int index); // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer) {}; void Print() {}; }; class FiducialItem { public: int id; double pose[3]; double upose[3]; }; class FiducialProxy : public ClientProxy { public: // the latest laser beacon data unsigned short count; double pose[3]; double size[2]; double fiducial_size[2]; double min_range; double max_range; double view_angle; FiducialItem beacons[PLAYER_FIDUCIAL_MAX_SAMPLES]; FiducialProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_FIDUCIAL_CODE,index,access) { count=0; } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); int PrintFOV(); int PrintGeometry(); int GetConfigure(); int GetFOV(); int SetId( int id ); int GetId( void ); int SetFOV( double min_range, double max_range, double view_angle); int SendMessage( player_fiducial_msg_t* msg, bool consume ); int RecvMessage( player_fiducial_msg_t* msg, bool consume ); }; class LaserProxy : public ClientProxy { public: int scan_count; double scan_res; double min_angle, max_angle; double range_res; bool intensity; double scan[PLAYER_LASER_MAX_SAMPLES][2]; double point[PLAYER_LASER_MAX_SAMPLES][2]; // TODO: haven't verified that intensities work yet: unsigned char intensities[PLAYER_LASER_MAX_SAMPLES]; double min_right,min_left; LaserProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_LASER_CODE,index,access) {} // these methods are the user's interface to this device int SetLaserState(const unsigned char state); int Configure(double min_angle, double max_angle, unsigned int scan_res, unsigned int range_res, bool intensity); int GetConfigure(); int RangeCount() { return scan_count; } double Ranges (int index) { if (index < scan_count) return scan[index][0]; else return 0; } double MinLeft () { return min_left; } double MinRight () { return min_right; } double operator [] (unsigned int index) { return Ranges(index); } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); void PrintConfig(); }; class localize_hypoth { public: // Pose estimate (m, m, radians) double mean[3]; // Covariance (m^2, radians^2) double cov[3][3]; // Weight associated with this hypothesis double weight; }; class LocalizeProxy : public ClientProxy { public: unsigned int map_size_x, map_size_y; double map_scale; int8_t *map_cells; int pending_count; int hypoth_count; localize_hypoth hypoths[PLAYER_LOCALIZE_MAX_HYPOTHS]; LocalizeProxy(PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_LOCALIZE_CODE,index,access) { map_cells=NULL; bzero(&hypoths,sizeof(hypoths)); } ~LocalizeProxy(); // these methods are the user's interface to this device // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); int SetPose(double pose[3], double cov[3][3]); int GetNumParticles(); // deprecated: get map from map interface instead #if 0 int GetMap(); #endif void Print(); }; class MotorProxy : public ClientProxy { private: double theta; double thetaspeed;; unsigned char stall; public: MotorProxy(PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_MOTOR_CODE,index,access) {} // these methods are the user's interface to this device int SetSpeed(double speed); int GoTo(double angle); int SetMotorState(unsigned char state); int SelectVelocityControl(unsigned char mode); int ResetOdometry(); int SetOdometry(double angle); int SelectPositionMode(unsigned char mode); int SetSpeedPID(double kp, double ki, double kd); int SetPositionPID(double kp, double ki, double kd); int SetPositionSpeedProfile(double spd, double acc); double Theta () const { return theta; } double ThetaSpeed () const { return thetaspeed; } unsigned char Stall () const { return stall; } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class PositionProxy : public ClientProxy { public: double pose[3]; double size[2]; double xpos,ypos,theta; double speed, sidespeed, turnrate; unsigned char stall; PositionProxy(PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_POSITION_CODE,index,access) {} // these methods are the user's interface to this device int PositionProxy::GetGeometry(); int SetSpeed(double speed, double sidespeed, double turnrate); int SetSpeed(double speed, double turnrate) { return(SetSpeed(speed,0.0,turnrate));} int GoTo(double x, double y, double t); int SetMotorState(unsigned char state); int SelectVelocityControl(unsigned char mode); int ResetOdometry(); // the following ioctls are currently only supported by reb_position // int SelectPositionMode(unsigned char mode); int SetOdometry(double x, double y, double t); int SetSpeedPID(int kp, int ki, int kd); int SetPositionPID(short kp, short ki, short kd); int SetPositionSpeedProfile(short spd, short acc); int DoStraightLine(int mm); int DoRotation(int deg); int DoDesiredHeading(int theta, int xspeed, int yawspeed); int SetStatus(uint8_t cmd, uint16_t value); int PlatformShutdown(); double Xpos () const { return xpos; } double Ypos () const { return ypos; } double Theta () const { return theta; } double Speed () const { return speed; } double SideSpeed () const { return sidespeed; } double TurnRate () const { return turnrate; } unsigned char Stall () const { return stall; } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class Position2DProxy : public ClientProxy { private: double xpos,ypos,yaw; double xspeed, yspeed, yawspeed; unsigned char stall; public: Position2DProxy(PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_POSITION_CODE,index,access) {} // these methods are the user's interface to this device int SetSpeed(double xspeed, double yspeed, double yawspeed); int SetSpeed(double speed, double turnrate) { return(SetSpeed(speed,0.0,turnrate));} int GoTo(double x, double y, double yaw); int SetMotorState(unsigned char state); int SelectVelocityControl(unsigned char mode); int ResetOdometry(); // the following ioctls are currently only supported by reb_position // int SelectPositionMode(unsigned char mode); int SetOdometry(double x, double y, double yaw); int SetSpeedPID(double kp, double ki, double kd); int SetPositionPID(double kp, double ki, double kd); int SetPositionSpeedProfile(double spd, double acc); int DoStraightLine(double m); int DoRotation(double yawspeed); int DoDesiredHeading(double yaw, double xspeed, double yawspeed); int SetStatus(uint8_t cmd, uint16_t value); int PlatformShutdown(); double Xpos () const { return xpos; } double Ypos () const { return ypos; } double Yaw () const { return yaw; } // Speed, SideSpeed, and TurnRate are left for backwards compatibility, but // could probably be dropped. double Speed () const { return xspeed; } double SideSpeed () const { return yspeed; } double TurnRate () const { return yawspeed; } double XSpeed () const { return xspeed; } double YSpeed () const { return yspeed; } double YawSpeed () const { return yawspeed; } unsigned char Stall () const { return stall; } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class Position3DProxy : public ClientProxy { private: double xpos,ypos,zpos; double roll,pitch,yaw; double xspeed, yspeed, zspeed; double rollspeed, pitchspeed, yawspeed; unsigned char stall; public: Position3DProxy(PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_POSITION3D_CODE,index,access) {} // these methods are the user's interface to this device int SetSpeed(double xspeed, double yspeed, double zspeed, double rollspeed, double pitchspeed, double yawspeed); int Position3DProxy::SetSpeed(double xspeed,double yspeed, double zspeed,double yawspeed) { return(SetSpeed(xspeed,yspeed,zspeed,0,0,yawspeed)); } int SetSpeed(double xspeed, double yspeed, double yawspeed) { return SetSpeed(xspeed, yspeed, 0, 0, 0, yawspeed); } int SetSpeed(double xspeed, double yawspeed) { return(SetSpeed(xspeed,0,0,0,0,yawspeed));} int GoTo(double x, double y, double z, double roll, double pitch, double yaw); int SetMotorState(unsigned char state); int SelectVelocityControl(unsigned char mode); int ResetOdometry(); int SetOdometry(double x, double y, double z, double roll, double pitch, double yaw); int SelectPositionMode(unsigned char mode); int SetSpeedPID(double kp, double ki, double kd); int SetPositionPID(double kp, double ki, double kd); int SetPositionSpeedProfile(double spd, double acc); // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); double Xpos() const { return xpos; } double Ypos() const { return ypos; } double Zpos() const { return zpos; } double Roll() const { return roll; } double Pitch() const { return pitch; } double Yaw() const { return yaw; } double XSpeed() const { return xspeed; } double YSpeed() const { return yspeed; } double ZSpeed() const { return zspeed; } double RollSpeed() const { return rollspeed; } double PitchSpeed() const { return pitchspeed; } double YawSpeed() const { return yawspeed; } unsigned char Stall () const { return stall; } }; class PtzProxy : public ClientProxy { public: double pan, tilt, zoom; double panspeed, tiltspeed; PtzProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_PTZ_CODE,index,access) {} // these methods are the user's interface to this device int SetCam(double pan, double tilt, double zoom); int SetSpeed(double panspeed, double tiltspeed); // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); int SendConfig(uint8_t *bytes, size_t len, uint8_t *reply = NULL, size_t reply_len = 0); int SelectControlMode(uint8_t mode); void Print(); }; class SonarProxy : public ClientProxy { public: unsigned short range_count; double ranges[PLAYER_SONAR_MAX_SAMPLES]; int pose_count; double poses[PLAYER_SONAR_MAX_SAMPLES][3]; SonarProxy(PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_SONAR_CODE,index,access) { memset(&poses,0,sizeof(poses)); range_count=pose_count=0; } // these methods are the user's interface to this device int SetSonarState(unsigned char state); int GetSonarGeom(); double operator [](unsigned int index) { if(index < sizeof(ranges)) return(ranges[index]); else return(0); } // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class SpeechProxy : public ClientProxy { public: SpeechProxy(PlayerClient* pc, unsigned short index, unsigned char access='c') : ClientProxy(pc,PLAYER_SPEECH_CODE,index,access) {} // these methods are the user's interface to this device int Say(char* str); }; class TruthProxy : public ClientProxy { public: double px, py, pz, rx, ry, rz; TruthProxy(PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_TRUTH_CODE,index,access) {}; // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); int GetPose( double *px, double *py, double *pz, double *rx, double *ry, double *rz ); int SetPose( double px, double py, double pz, double rx, double ry, double rz); int SetPoseOnRoot( double px, double py, double pz, double rx, double ry, double rz); int GetFiducialID( int16_t* id ); int SetFiducialID( int16_t id ); }; class Blob { public: unsigned int id; unsigned int color; unsigned int area; unsigned short x; unsigned short y; unsigned short left; unsigned short right; unsigned short top; unsigned short bottom; double range; }; class BlobfinderProxy : public ClientProxy { public: unsigned short width, height; int blob_count; Blob blobs[PLAYER_BLOBFINDER_MAX_BLOBS]; BlobfinderProxy(PlayerClient* pc, unsigned short index, unsigned char access='c'); ~BlobfinderProxy(); // these methods are the user's interface to this device // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); void Print(); int SetTrackingColor(); int SetTrackingColor(int rmin, int rmax, int gmin, int gmax, int bmin, int bmax); int SetImagerParams(int contrast, int brightness, int autogain, int colormode); int SetContrast(int c); int SetColorMode(int m); int SetBrightness(int b); int SetAutoGain(int g); }; // these define default coefficients for our // range and standard deviation estimates #define IRPROXY_DEFAULT_DIST_M_VALUE -0.661685227 #define IRPROXY_DEFAULT_DIST_B_VALUE 10.477102515 #define IRPROXY_DEFAULT_STD_M_VALUE 1.913005560938 #define IRPROXY_DEFAULT_STD_B_VALUE -7.728130591833 #define IRPROXY_M_PARAM 0 #define IRPROXY_B_PARAM 1 //this is the effective range of the sensor in mm #define IRPROXY_MAX_RANGE 700 class IRProxy : public ClientProxy { public: unsigned short ranges[PLAYER_IR_MAX_SAMPLES]; unsigned short voltages[PLAYER_IR_MAX_SAMPLES]; double stddev[PLAYER_IR_MAX_SAMPLES]; double params[PLAYER_IR_MAX_SAMPLES][2]; double sparams[PLAYER_IR_MAX_SAMPLES][2]; player_ir_pose_t ir_pose; IRProxy(PlayerClient *pc, unsigned short index, unsigned char access = 'c'); int SetIRState(unsigned char state); int GetIRPose(); void SetRangeParams(int which, double m, double ); void SetStdDevParams(int which, double m, double b); double CalcStdDev(int w, unsigned short range); unsigned short operator [](unsigned int index) { if (index < PLAYER_IR_MAX_SAMPLES) { return ranges[index]; } return 0; } // required methods void FillData(player_msghdr_t hdr, const char *buffer); void Print(); }; class WiFiProxy: public ClientProxy { public: WiFiProxy(PlayerClient *pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc, PLAYER_WIFI_CODE, index, access), link_count(0) {} int GetLinkQuality(char * ip = NULL); int GetLevel(char * ip = NULL); int GetLeveldBm(char * ip = NULL) { return GetLevel(ip) - 0x100; } int GetNoise(char * ip = NULL); int GetNoisedBm(char * ip = NULL) { return GetNoise(ip) - 0x100; } uint16_t GetMaxLinkQuality() { return maxqual; } uint8_t GetMode() { return op_mode; } int GetBitrate(); char * GetMAC(char *buf, int len); char * GetIP(char *buf, int len); char * GetAP(char *buf, int len); int AddSpyHost(char *address); int RemoveSpyHost(char *address); void FillData(player_msghdr_t hdr, const char *buffer); void Print(); protected: int GetLinkIndex(char *ip); int link_count; player_wifi_link_t links[PLAYER_WIFI_MAX_LINKS]; uint32_t throughput; uint8_t op_mode; int32_t bitrate; uint16_t qual_type, maxqual, maxlevel, maxnoise; char access_point[32]; }; class PowerProxy : public ClientProxy { public: PowerProxy (PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_POWER_CODE,index,access) {} double Charge () const { return charge; } // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); private: // Remaining power in volts double charge; }; class AudioProxy : public ClientProxy { public: uint16_t frequency0, amplitude0; uint16_t frequency1, amplitude1; uint16_t frequency2, amplitude2; uint16_t frequency3, amplitude3; uint16_t frequency4, amplitude4; AudioProxy (PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_AUDIO_CODE,index,access) {} // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); int PlayTone(unsigned short freq, unsigned short amp, unsigned short dur); void Print (); }; class AudioDSPProxy : public ClientProxy { public: int16_t sampleFormat; uint16_t sampleRate; uint8_t channels; uint16_t freq[5]; uint16_t amp[5]; AudioDSPProxy (PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_AUDIODSP_CODE,index,access) {} int Configure(uint8_t channels, uint16_t sampleRate, int16_t sampleFormat=0xFFFFFFFF ); int GetConfigure(); // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); int PlayTone(unsigned short freq, unsigned short amp, unsigned int dur); int PlayChirp(unsigned short freq, unsigned short amp, unsigned int dur, const unsigned char bitString[], unsigned short bitStringLen); int Replay(); void Print (); }; class AudioMixerProxy : public ClientProxy { public: unsigned short masterLeft, masterRight; unsigned short pcmLeft, pcmRight; unsigned short lineLeft, lineRight; unsigned short micLeft, micRight; unsigned short iGain, oGain; AudioMixerProxy (PlayerClient* pc, unsigned short index, unsigned char access ='c') : ClientProxy(pc,PLAYER_AUDIOMIXER_CODE,index,access) {} int GetConfigure(); // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); int SetMaster(unsigned short left, unsigned short right); int SetPCM(unsigned short left, unsigned short right); int SetLine(unsigned short left, unsigned short right); int SetMic(unsigned short left, unsigned short right); int SetIGain(unsigned short gain); int SetOGain(unsigned short gain); // Print the current data. void Print (); }; class BumperProxy : public ClientProxy { public: BumperProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_BUMPER_CODE,index,access) {} ~BumperProxy() {} // these methods are the user's interface to this device bool Bumped (const unsigned int i); bool BumpedAny (); int GetBumperGeom( player_bumper_geom_t* bumper_defs ); uint8_t BumperCount () const { return bumper_count; } // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); private: uint8_t bumper_count; uint8_t bumpers[PLAYER_BUMPER_MAX_SAMPLES]; }; class DIOProxy : public ClientProxy { public: DIOProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_DIO_CODE,index,access) {} ~DIOProxy() {} uint8_t count; uint32_t digin; int SetOutput(uint8_t output_count, uint32_t digout); // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); }; class WaveformProxy : public ClientProxy { public: WaveformProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_WAVEFORM_CODE,index,access) { this->ConfigureDSP(); // use latest settings } ~WaveformProxy(); unsigned int bitrate; unsigned short depth; unsigned int last_samples; unsigned char buffer[PLAYER_WAVEFORM_DATA_MAX]; int fd; // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); // set up the DSP to the current bitrate and depth int ConfigureDSP() ; // open the sound device void OpenDSPforWrite(); // Play the waveform through the DSP void Play(); }; class MComProxy : public ClientProxy { public: player_mcom_data_t data; int type; char channel[MCOM_CHANNEL_LEN]; public: MComProxy(PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_MCOM_CODE,index,access){} int Pop(int type, char channel[MCOM_CHANNEL_LEN]); int Read(int type, char channel[MCOM_CHANNEL_LEN]); int Push(int type, char channel[MCOM_CHANNEL_LEN], char dat[MCOM_DATA_LEN]); int Clear(int type, char channel[MCOM_CHANNEL_LEN]); int SetCapacity(int type, char channel[MCOM_CHANNEL_LEN], unsigned char cap); char* LastData() { return data.data; } int LastMsgType() { return type; } char* LastChannel() { return channel; } void FillData(player_msghdr_t hdr, const char* buffer); void Print(); }; class BlinkenlightProxy : public ClientProxy { public: BlinkenlightProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_BLINKENLIGHT_CODE,index,access) { // assume the light is off by default this->period_ms = 0; this->enable = false; } virtual ~BlinkenlightProxy() { }; bool enable; int period_ms; // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); int SetLight( bool enable, int period_ms ); }; class CameraProxy : public ClientProxy { public: // Constructor. Leave the access field empty to start unconnected. CameraProxy (PlayerClient *pc, unsigned short index, unsigned char access='c'); virtual ~CameraProxy(); // Image color depth uint8_t depth; // Image dimensions (pixels) uint16_t width, height; // Sime of the image (bytes) uint32_t imageSize; // Image data uint8_t* image; // interface that all proxies must provide void FillData(player_msghdr_t hdr, const char* buffer); // prints out basic statistics of the camera void Print(); void SaveFrame(const char *prefix); private: char filename[256]; int frameNo; }; class PlannerProxy : public ClientProxy { // Constructor. Leave the access field empty to start unconnected. public: PlannerProxy (PlayerClient *pc, unsigned short index, unsigned char access='c'); // Destructor public: virtual ~PlannerProxy(); public: int SetCmdPose( double gx, double gy, double ga); public: int GetWaypoints(); public: int Enable(int state); // interface that all proxies must provide public: void FillData( player_msghdr_t hdr, const char *buffer); public: bool pathValid; public: bool pathDone; public: double px, py, pa; public: double gx, gy, ga; public: double wx, wy, wa; public: short currWaypoint; public: short waypointCount; public: double waypoints[PLAYER_PLANNER_MAX_WAYPOINTS][3]; }; class EnergyProxy : public ClientProxy { public: EnergyProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_ENERGY_CODE,index,access) {} ~EnergyProxy() {} // these methods are the user's interface to this device // interface that all proxies must provide void FillData (player_msghdr_t hdr, const char* buffer); void Print (); double joules; double watts; bool charging; }; class MapProxy : public ClientProxy { // Constructor public: MapProxy (PlayerClient *pc, unsigned short indes, unsigned char access='c'); // Destructor public: ~MapProxy(); public: int GetMap(); public: int GetCellIndex( int x, int y ); public: int GetCell( char* cell, int x, int y ); // interface that all proxies must provide public: void FillData (player_msghdr_t hde, const char *buffer); public: double resolution; /* Map size, in cells */ public: int width, height; public: char *cells; }; class SpeechRecognitionProxy : public ClientProxy { // Constructor public: SpeechRecognitionProxy (PlayerClient *pc, unsigned short indes, unsigned char access='c'); // Destructor public: ~SpeechRecognitionProxy(); // interface that all proxies must provide public: void FillData (player_msghdr_t hde, const char *buffer); public: void Clear(); public: char rawText[SPEECH_RECOGNITION_TEXT_LEN]; // Just estimating that no more than 20 words will be spoken between updates. // Assuming that the longest word is <= 30 characters. public: char words[20][30]; public: int wordCount; }; class SimulationProxy : public ClientProxy { public: SimulationProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_SIMULATION_CODE,index,access) {} ~SimulationProxy() {} int SetPose2D( char* identifier, double x, double y, double a ); int GetPose2D( char* identifier, double& x, double& y, double& a ); virtual void FillData(player_msghdr_t hdr, const char* buffer); virtual void Print(); }; class LogProxy : public ClientProxy { public: LogProxy (PlayerClient* pc, unsigned short index, unsigned char access = 'c') : ClientProxy(pc,PLAYER_LOG_CODE,index,access) {} ~LogProxy() {} int type; int state; int LogProxy::GetState(); int LogProxy::SetWriteState(int state); int LogProxy::SetReadState(int state); int LogProxy::Rewind(); int LogProxy::SetFilename(const char* fname); virtual void FillData(player_msghdr_t hdr, const char* buffer); virtual void Print(); }; #endif