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

playerc++.h

/*
 *  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
 *
 */
/********************************************************************
 *
 *  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
 *
 ********************************************************************/

/***************************************************************************
 * Desc: Player v2.0 C++ client
 * Authors: Brad Kratochvil, Toby Collett
 *
 * Date: 23 Sep 2005
 # CVS: $Id: playerc++.h 6996 2008-08-30 02:45:26Z thjc $
 **************************************************************************/


#ifndef PLAYERCC_H
#define PLAYERCC_H

#include <cmath>
#include <string>
#include <list>
#include <vector>
#include <cstring>

#include "libplayerc/playerc.h"
#include "libplayerc++/utility.h"
#include "libplayerc++/playerc++config.h"
#include "libplayerc++/playerclient.h"
#include "libplayerc++/playererror.h"
#include "libplayerc++/clientproxy.h"
#include "libplayercore/interface_util.h"

// Don't think we need to include these here
/*
#ifdef HAVE_BOOST_SIGNALS
  #include <boost/signal.hpp>
  #include <boost/bind.hpp>
#endif

#ifdef HAVE_BOOST_THREAD
  #include <boost/thread/mutex.hpp>
  #include <boost/thread/thread.hpp>
  #include <boost/thread/xtime.hpp>
#endif
*/

namespace PlayerCc
{

// /**
// * The @p SomethingProxy class is a template for adding new subclasses of
// * ClientProxy.  You need to have at least all of the following:
// */
// class SomethingProxy : public ClientProxy
// {
//
//   private:
//
//     // Subscribe
//     void Subscribe(uint32_t aIndex);
//     // Unsubscribe
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_something_t *mDevice;
//
//   public:
//     // Constructor
//     SomethingProxy(PlayerClient *aPc, uint32_t aIndex=0);
//     // Destructor
//     ~SomethingProxy();
//
// };

// ==============================================================
//
// These are alphabetized, please keep them that way!!!
//
// ==============================================================

class ActArrayProxy : public ClientProxy
{
  private:

   void Subscribe(uint32_t aIndex);
   void Unsubscribe();

   // libplayerc data structure
   playerc_actarray_t *mDevice;

  public:

    ActArrayProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~ActArrayProxy();

    void RequestGeometry(void);

    void SetPowerConfig(bool aVal);
    void SetBrakesConfig(bool aVal);
    void SetSpeedConfig(uint32_t aJoint, float aSpeed);

    void MoveTo(uint32_t aJoint, float aPos);
    void MoveToMulti(std::vector<float> aPos);
    void MoveAtSpeed(uint32_t aJoint, float aSpeed);
    void MoveAtSpeedMulti(std::vector<float> aSpeed);
    void MoveHome(int aJoint);
    void SetActuatorCurrent(uint32_t aJoint, float aCurrent);
    void SetActuatorCurrentMulti(std::vector<float> aCurrent);

    uint32_t GetCount(void) const { return GetVar(mDevice->actuators_count); }
    player_actarray_actuator_t GetActuatorData(uint32_t aJoint) const;
    player_actarray_actuatorgeom_t GetActuatorGeom(uint32_t aJoint) const;
    player_point_3d_t GetBasePos(void) const { return GetVar(mDevice->base_pos); }
    player_orientation_3d_t GetBaseOrientation(void) const { return GetVar(mDevice->base_orientation); }


    player_actarray_actuator_t operator [](uint32_t aJoint)
      { return(GetActuatorData(aJoint)); }
};

class AioProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_aio_t *mDevice;

  public:

    AioProxy (PlayerClient *aPc, uint32_t aIndex=0);
    ~AioProxy();

    uint32_t GetCount() const { return(GetVar(mDevice->voltages_count)); };

    double GetVoltage(uint32_t aIndex)  const
      { return(GetVar(mDevice->voltages[aIndex])); };

    void SetVoltage(uint32_t aIndex, double aVoltage);

    double operator [](uint32_t aIndex) const
      { return GetVoltage(aIndex); }

};


class AudioProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audio_t *mDevice;

  public:

    AudioProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~AudioProxy();

    uint32_t GetMixerDetailsCount() const {return(GetVar(mDevice->channel_details_list.details_count));};
    player_audio_mixer_channel_detail_t GetMixerDetails(int aIndex) const  {return(GetVar(mDevice->channel_details_list.details[aIndex]));};
    uint32_t GetDefaultOutputChannel() const  {return(GetVar(mDevice->channel_details_list.default_output));};
    uint32_t GetDefaultInputChannel() const {return(GetVar(mDevice->channel_details_list.default_input));};

    uint32_t GetWavDataLength() const {return(GetVar(mDevice->wav_data.data_count));};
    void GetWavData(uint8_t* aData) const
      {
        return GetVarByRef(mDevice->wav_data.data,
                           mDevice->wav_data.data+GetWavDataLength(),
                           aData);
      };

    uint32_t GetSeqCount() const {return(GetVar(mDevice->seq_data.tones_count));};
    player_audio_seq_item_t GetSeqItem(int aIndex) const  {return(GetVar(mDevice->seq_data.tones[aIndex]));};

    uint32_t GetChannelCount() const {return(GetVar(mDevice->mixer_data.channels_count));};
    player_audio_mixer_channel_t GetChannel(int aIndex) const  {return(GetVar(mDevice->mixer_data.channels[aIndex]));};
    uint32_t GetState(void) const {return(GetVar(mDevice->state));};



    void PlayWav(uint32_t aDataCount, uint8_t *aData, uint32_t aFormat);

    void SetWavStremRec(bool aState);

    void PlaySample(int aIndex);

    void PlaySeq(player_audio_seq_t * aTones);

    void SetMultMixerLevels(player_audio_mixer_channel_list_t * aLevels);

    void SetMixerLevel(uint32_t index, float amplitude, uint8_t active);

    void RecordWav();

    void LoadSample(int aIndex, uint32_t aDataCount, uint8_t *aData, uint32_t aFormat);

    void GetSample(int aIndex);

    void RecordSample(int aIndex, uint32_t aLength);

    void GetMixerLevels();

    void GetMixerDetails();

};

class BlackBoardProxy : public ClientProxy
{
  private:
    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blackboard_t *mDevice;

  public:
        BlackBoardProxy(PlayerClient *aPc, uint aIndex=0);
        ~BlackBoardProxy();
        player_blackboard_entry_t *SubscribeToKey(const char *key, const char* group = "");
        void UnsubscribeFromKey(const char *key, const char* group = "");
        void SubscribeToGroup(const char* key);
        void UnsubscribeFromGroup(const char* group);
        void SetEntry(const player_blackboard_entry_t &entry);
        player_blackboard_entry_t *GetEntry(const char* key, const char* group);
        void SetEventHandler(void (*on_blackboard_event)(playerc_blackboard_t *, player_blackboard_entry_t));
};

// /**
// The @p BlinkenlightProxy class is used to enable and disable
// a flashing indicator light, and to set its period, via a @ref
// interface_blinkenlight device */
// class BlinkenLightProxy : public ClientProxy
// {
//   private:
//
//     void Subscribe(uint32_t aIndex);
//     void Unsubscribe();
//
//     // libplayerc data structure
//     playerc_blinkenlight_t *mDevice;
//
//   public:
//     /** Constructor.
//         Leave the access field empty to start unconnected.
//     */
//     BlinkenLightProxy(PlayerClient *aPc, uint32_t aIndex=0);
//     ~BlinkenLightProxy();
//
//     // true: indicator light enabled, false: disabled.
//     bool GetEnable();
//
//     /** The current period (one whole on/off cycle) of the blinking
//         light. If the period is zero and the light is enabled, the light
//         is on.
//     */
//     void SetPeriod(double aPeriod);
//
//     /** Set the state of the indicator light. A period of zero means
//         the light will be unblinkingly on or off. Returns 0 on
//         success, else -1.
//       */
//     void SetEnable(bool aSet);
// };

class BlobfinderProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blobfinder_t *mDevice;

  public:
    BlobfinderProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~BlobfinderProxy();

    uint32_t GetCount() const { return GetVar(mDevice->blobs_count); };
    playerc_blobfinder_blob_t GetBlob(uint32_t aIndex) const
      { return GetVar(mDevice->blobs[aIndex]);};

    uint32_t GetWidth() const { return GetVar(mDevice->width); };
    uint32_t GetHeight() const { return GetVar(mDevice->height); };

    playerc_blobfinder_blob_t operator [](uint32_t aIndex) const
      { return(GetBlob(aIndex)); }

/*
    void SetTrackingColor(uint32_t aReMin=0,   uint32_t aReMax=255, uint32_t aGrMin=0,
                          uint32_t aGrMax=255, uint32_t aBlMin=0,   uint32_t aBlMax=255);
    void SetImagerParams(int aContrast, int aBrightness,
                         int aAutogain, int aColormode);
    void SetContrast(int aC);
    void SetColorMode(int aM);
    void SetBrightness(int aB);
    void SetAutoGain(int aG);*/

};

class BumperProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_bumper_t *mDevice;

  public:

    BumperProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~BumperProxy();

    uint32_t GetCount() const { return GetVar(mDevice->bumper_count); };

    uint32_t IsBumped(uint32_t aIndex) const
      { return GetVar(mDevice->bumpers[aIndex]); };

    bool IsAnyBumped();

    void RequestBumperConfig();

    uint32_t GetPoseCount() const { return GetVar(mDevice->pose_count); };

    player_bumper_define_t GetPose(uint32_t aIndex) const
      { return GetVar(mDevice->poses[aIndex]); };

    bool operator [](uint32_t aIndex) const
      { return IsBumped(aIndex); }

};

class CameraProxy : public ClientProxy
{

  private:

    virtual void Subscribe(uint32_t aIndex);
    virtual void Unsubscribe();

    // libplayerc data structure
    playerc_camera_t *mDevice;

    std::string mPrefix;
    int mFrameNo;

  public:

    CameraProxy (PlayerClient *aPc, uint32_t aIndex=0);

    virtual ~CameraProxy();

    void SaveFrame(const std::string aPrefix, uint32_t aWidth=4);

    void Decompress();

    uint32_t GetDepth() const { return GetVar(mDevice->bpp); };

    uint32_t GetWidth() const { return GetVar(mDevice->width); };

    uint32_t GetHeight() const { return GetVar(mDevice->height); };

    uint32_t GetFormat() const { return GetVar(mDevice->format); };

    uint32_t GetImageSize() const { return GetVar(mDevice->image_count); };

    void GetImage(uint8_t* aImage) const
      {
        return GetVarByRef(mDevice->image,
                           mDevice->image+GetVar(mDevice->image_count),
                           aImage);
      };

    uint32_t GetCompression() const { return GetVar(mDevice->compression); };

};


class DioProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_dio_t *mDevice;

  public:
    DioProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~DioProxy();

    uint32_t GetCount() const { return GetVar(mDevice->count); };

    uint32_t GetDigin() const { return GetVar(mDevice->digin); };

    bool GetInput(uint32_t aIndex) const;

    void SetOutput(uint32_t aCount, uint32_t aDigout);

    uint32_t operator [](uint32_t aIndex) const
      { return GetInput(aIndex); }
};

class FiducialProxy : public ClientProxy
{
  private:
    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_fiducial_t *mDevice;

  public:
    FiducialProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~FiducialProxy();

    uint32_t GetCount() const { return GetVar(mDevice->fiducials_count); };

    player_fiducial_item_t GetFiducialItem(uint32_t aIndex) const
      { return GetVar(mDevice->fiducials[aIndex]);};

    player_pose3d_t GetSensorPose() const
      { return GetVar(mDevice->fiducial_geom.pose);};

    player_bbox3d_t GetSensorSize() const
      { return GetVar(mDevice->fiducial_geom.size);};

    player_bbox2d_t GetFiducialSize() const
      { return GetVar(mDevice->fiducial_geom.fiducial_size);};

    void RequestGeometry();

    player_fiducial_item_t operator [](uint32_t aIndex) const
      { return GetFiducialItem(aIndex); }
};

class GpsProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gps_t *mDevice;

  public:

    // Constructor
    GpsProxy(PlayerClient *aPc, uint32_t aIndex=0);

    ~GpsProxy();

    double GetLatitude() const { return GetVar(mDevice->lat); };
    double GetLongitude() const { return GetVar(mDevice->lon); };

    double GetAltitude() const { return GetVar(mDevice->alt); };

    uint32_t GetSatellites() const { return GetVar(mDevice->sat_count); };

    uint32_t GetQuality() const { return GetVar(mDevice->quality); };

    double GetHdop() const { return GetVar(mDevice->hdop); };

    double GetVdop() const { return GetVar(mDevice->vdop); };

    double GetUtmEasting() const { return GetVar(mDevice->utm_e); };
    double GetUtmNorthing() const { return GetVar(mDevice->utm_n); };

    double GetTime() const { return GetVar(mDevice->utc_time); };

    double GetErrHorizontal() const { return GetVar(mDevice->err_horz); };
    double GetErrVertical() const { return GetVar(mDevice->err_vert); };
};

class Graphics2dProxy : public ClientProxy
{

  private:

    // Subscribe
    void Subscribe(uint32_t aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_graphics2d_t *mDevice;

  public:
    // Constructor
    Graphics2dProxy(PlayerClient *aPc, uint32_t aIndex=0);
    // Destructor
    ~Graphics2dProxy();

    void Color(player_color_t col);

    void Color(uint8_t red,  uint8_t green,  uint8_t blue,  uint8_t alpha);

    void Clear(void);

    void DrawPoints(player_point_2d_t pts[], int count);

    void DrawPolygon(player_point_2d_t pts[],
                     int count,
                     bool filled,
                     player_color_t fill_color);

    void DrawPolyline(player_point_2d_t pts[], int count);
};

class Graphics3dProxy : public ClientProxy
{

  private:

    // Subscribe
    void Subscribe(uint32_t aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_graphics3d_t *mDevice;

  public:
    // Constructor
    Graphics3dProxy(PlayerClient *aPc, uint32_t aIndex=0);
    // Destructor
    ~Graphics3dProxy();

    void Color(player_color_t col);

    void Color(uint8_t red,  uint8_t green,  uint8_t blue,  uint8_t alpha);

    void Clear(void);

    void Draw(player_graphics3d_draw_mode_t mode, player_point_3d_t pts[], int count);

};

class GripperProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gripper_t *mDevice;

  public:

    GripperProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~GripperProxy();

    void RequestGeometry(void);

    uint32_t GetState() const { return GetVar(mDevice->state); };
    uint32_t GetBeams() const { return GetVar(mDevice->beams); };
    player_pose3d_t GetPose() const { return GetVar(mDevice->pose); };
    player_bbox3d_t GetOuterSize() const { return GetVar(mDevice->outer_size); };
    player_bbox3d_t GetInnerSize() const { return GetVar(mDevice->inner_size); };
    uint32_t GetNumBeams() const { return GetVar(mDevice->num_beams); };
    uint32_t GetCapacity() const { return GetVar(mDevice->capacity); };
    uint32_t GetStored() const { return GetVar(mDevice->stored); };

    void Open();
    void Close();
    void Stop();
    void Store();
    void Retrieve();
};

class HealthProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_health_t *mDevice;

  public:
    HealthProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~HealthProxy();

    float GetIdleCPU();

    float GetSystemCPU();

    float GetUserCPU();

    int64_t GetMemTotal();

    int64_t GetMemUsed();

    int64_t GetMemFree();

    int64_t GetSwapTotal();

    int64_t GetSwapUsed();

    int64_t GetSwapFree();

    float GetPercMemUsed();

    float GetPercSwapUsed();

    float GetPercTotalUsed();
};



class ImuProxy : public ClientProxy
{
  private:
    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_imu_t *mDevice;

  public:

    ImuProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~ImuProxy();

    player_pose3d_t GetPose() const { return GetVar(mDevice->pose); };
    float GetXAccel();
    float GetYAccel();
    float GetZAccel();
    float GetXGyro();
    float GetYGyro();
    float GetZGyro();
    float GetXMagn();
    float GetYMagn();
    float GetZMagn();

    player_imu_data_calib_t GetRawValues() const
    { return GetVar(mDevice->calib_data); };

    void SetDatatype(int aDatatype);

    void ResetOrientation(int aValue);
    

};


class IrProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ir_t *mDevice;

  public:

    IrProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~IrProxy();

    uint32_t GetCount() const { return GetVar(mDevice->data.ranges_count); };
    double GetRange(uint32_t aIndex) const
      { return GetVar(mDevice->data.ranges[aIndex]); };
    double GetVoltage(uint32_t aIndex) const
      { return GetVar(mDevice->data.voltages[aIndex]); };
    uint32_t GetPoseCount() const { return GetVar(mDevice->poses.poses_count); };
    player_pose3d_t GetPose(uint32_t aIndex) const
      {return GetVar(mDevice->poses.poses[aIndex]);};

    void RequestGeom();

    double operator [](uint32_t aIndex) const
      { return GetRange(aIndex); }

};

class LaserProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_laser_t *mDevice;

    // local storage of config
    double min_angle, max_angle, scan_res, range_res, scanning_frequency;
    bool intensity;

  public:

    LaserProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~LaserProxy();

    uint32_t GetCount() const { return GetVar(mDevice->scan_count); };

    double GetMaxRange() const { return GetVar(mDevice->max_range); };

    double GetScanRes() const { return GetVar(mDevice->scan_res); };

    double GetRangeRes() const { return GetVar(mDevice->range_res); };

    double GetScanningFrequency() const { return GetVar(mDevice->scanning_frequency); };

    double GetMinAngle() const { return GetVar(mDevice->scan_start); };
    double GetMaxAngle() const
    {
      scoped_lock_t lock(mPc->mMutex);
      return mDevice->scan_start + (mDevice->scan_count - 1)*mDevice->scan_res;
    };

    double GetConfMinAngle() const { return min_angle; };
    double GetConfMaxAngle() const { return max_angle; };

    bool IntensityOn() const { return GetVar(mDevice->intensity_on); };

//    /// Scan data (polar): range (m) and bearing (radians)
//    double GetScan(uint32_t aIndex) const
//      { return GetVar(mDevice->scan[aIndex]); };

    player_point_2d_t GetPoint(uint32_t aIndex) const
      { return GetVar(mDevice->point[aIndex]); };


    double GetRange(uint32_t aIndex) const
      { return GetVar(mDevice->ranges[aIndex]); };

    double GetBearing(uint32_t aIndex) const
      { return GetVar(mDevice->scan[aIndex][1]); };


    int GetIntensity(uint32_t aIndex) const
      { return GetVar(mDevice->intensity[aIndex]); };

    int GetID() const
      { return GetVar(mDevice->laser_id); };


    void Configure(double aMinAngle,
                   double aMaxAngle,
                   uint32_t aScanRes,
                   uint32_t aRangeRes,
                   bool aIntensity,
                   double aScanningFrequency);

    void RequestConfigure();
    
    void RequestID();

    void RequestGeom();

    player_pose3d_t GetPose()
    {
      player_pose3d_t p;
      scoped_lock_t lock(mPc->mMutex);

      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pyaw = mDevice->pose[2];
      return(p);
    }

    player_pose3d_t GetRobotPose()
    {
      player_pose3d_t p;
      scoped_lock_t lock(mPc->mMutex);

      p.px = mDevice->robot_pose[0];
      p.py = mDevice->robot_pose[1];
      p.pyaw = mDevice->robot_pose[2];
      return(p);
    }

    player_bbox3d_t GetSize()
    {
      player_bbox3d_t b;
      scoped_lock_t lock(mPc->mMutex);

      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }
    
    double GetMinLeft() const
      { return GetVar(mDevice->min_left); };
    
    double GetMinRight() const
      { return GetVar(mDevice->min_right); };
           
    double MinLeft () const 
      { return GetMinLeft(); }

    double MinRight () const
      { return GetMinRight(); }

    double operator [] (uint32_t index) const
      { return GetRange(index);}

};


class LimbProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

   // libplayerc data structure
    playerc_limb_t *mDevice;

  public:

    LimbProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~LimbProxy();

    void RequestGeometry(void);

    void SetPowerConfig(bool aVal);
    void SetBrakesConfig(bool aVal);
    void SetSpeedConfig(float aSpeed);

    void MoveHome(void);
    void Stop(void);
    void SetPose(float aPX, float aPY, float aPZ,
                 float aAX, float aAY, float aAZ,
                 float aOX, float aOY, float aOZ);
    void SetPosition(float aX, float aY, float aZ);
    void VectorMove(float aX, float aY, float aZ, float aLength);

    player_limb_data_t GetData(void) const;
    player_limb_geom_req_t GetGeom(void) const;
};



class LocalizeProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_localize_t *mDevice;

  public:

    LocalizeProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~LocalizeProxy();

    // @todo should these be in a player_pose_t?
    uint32_t GetMapSizeX() const { return GetVar(mDevice->map_size_x); };
    uint32_t GetMapSizeY() const { return GetVar(mDevice->map_size_y); };

    // @todo should these be in a player_pose_t?
    uint32_t GetMapTileX() const { return GetVar(mDevice->map_tile_x); };
    uint32_t GetMapTileY() const { return GetVar(mDevice->map_tile_y); };

    double GetMapScale() const { return GetVar(mDevice->map_scale); };

    // Map data (empty = -1, unknown = 0, occupied = +1)
    // is this still needed?  if so,
    //void GetMapCells(uint8_t* aCells) const
    //{
    //  return GetVarByRef(mDevice->map_cells,
    //                     mDevice->image+GetVar(mDevice->??map_cell_cout??),
    //                     aCells);
    //};

    uint32_t GetPendingCount() const { return GetVar(mDevice->pending_count); };

    uint32_t GetHypothCount() const { return GetVar(mDevice->hypoth_count); };

    player_localize_hypoth_t GetHypoth(uint32_t aIndex) const
      { return GetVar(mDevice->hypoths[aIndex]); };

    int GetParticles()
      { return playerc_localize_get_particles(mDevice); }

    player_pose2d_t GetParticlePose(int index) const;

    void SetPose(double pose[3], double cov[3]);

    uint32_t GetNumHypoths() const { return GetVar(mDevice->hypoth_count); };

    uint32_t GetNumParticles() const { return GetVar(mDevice->num_particles); };
};


class LogProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_log_t *mDevice;

  public:
    LogProxy(PlayerClient *aPc, uint32_t aIndex=0);

    ~LogProxy();

    int GetType() const { return GetVar(mDevice->type); };

    int GetState() const { return GetVar(mDevice->state); };

    void QueryState();

    void SetState(int aState);

    void SetWriteState(int aState);

    void SetReadState(int aState);

    void Rewind();

    void SetFilename(const std::string aFilename);
};

class MapProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_map_t *mDevice;

  public:
    MapProxy(PlayerClient *aPc, uint32_t aIndex=0);

    ~MapProxy();

    void RequestMap();

    int GetCellIndex(int x, int y) const
    { return y*GetWidth() + x; };

    int8_t GetCell(int x, int y) const
    { return GetVar(mDevice->cells[GetCellIndex(x,y)]); };

    double GetResolution() const { return GetVar(mDevice->resolution); };

    uint32_t GetWidth() const { return GetVar(mDevice->width); };
    uint32_t GetHeight() const { return GetVar(mDevice->height); };

    double GetOriginX() const { return GetVar(mDevice->origin[0]); };
    double GetOriginY() const { return GetVar(mDevice->origin[1]); };

    void GetMap(int8_t* aMap) const
    {
      return GetVarByRef(reinterpret_cast<int8_t*>(mDevice->cells),
                         reinterpret_cast<int8_t*>(mDevice->cells+GetWidth()*GetHeight()),
                         aMap);
    };
};

class OpaqueProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_opaque_t *mDevice;

  public:

    OpaqueProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~OpaqueProxy();

    uint32_t GetCount() const { return GetVar(mDevice->data_count); };

    void GetData(uint8_t* aDest) const
      {
        return GetVarByRef(mDevice->data,
                           mDevice->data+GetVar(mDevice->data_count),
                           aDest);
      };

    void SendCmd(player_opaque_data_t* aData);

    int SendReq(player_opaque_data_t* aRequest);

};

class PlannerProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_planner_t *mDevice;

  public:

    PlannerProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~PlannerProxy();

    void SetGoalPose(double aGx, double aGy, double aGa);

    void RequestWaypoints();

    void SetEnable(bool aEnable);

    uint32_t GetPathValid() const { return GetVar(mDevice->path_valid); };

    uint32_t GetPathDone() const { return GetVar(mDevice->path_done); };

    double GetPx() const { return GetVar(mDevice->px); };
    double GetPy() const { return GetVar(mDevice->py); };
    double GetPa() const { return GetVar(mDevice->pa); };

    player_pose2d_t GetPose() const
    {
      player_pose2d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->px;
      p.py = mDevice->py;
      p.pa = mDevice->pa;
      return(p);
    }

    double GetGx() const { return GetVar(mDevice->gx); };
    double GetGy() const { return GetVar(mDevice->gy); };
    double GetGa() const { return GetVar(mDevice->ga); };

    player_pose2d_t GetGoal() const
    {
      player_pose2d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->gx;
      p.py = mDevice->gy;
      p.pa = mDevice->ga;
      return(p);
    }

    double GetWx() const { return GetVar(mDevice->wx); };
    double GetWy() const { return GetVar(mDevice->wy); };
    double GetWa() const { return GetVar(mDevice->wa); };

    player_pose2d_t GetCurrentWaypoint() const
    {
      player_pose2d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->wx;
      p.py = mDevice->wy;
      p.pa = mDevice->wa;
      return(p);
    }

    double GetIx(int i) const;
    double GetIy(int i) const;
    double GetIa(int i) const;

    player_pose2d_t GetWaypoint(uint32_t aIndex) const
    {
      assert(aIndex < GetWaypointCount());
      player_pose2d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->waypoints[aIndex][0];
      p.py = mDevice->waypoints[aIndex][1];
      p.pa = mDevice->waypoints[aIndex][2];
      return(p);
    }

    int GetCurrentWaypointId() const
      { return GetVar(mDevice->curr_waypoint); };

    uint32_t GetWaypointCount() const
      { return GetVar(mDevice->waypoint_count); };

    player_pose2d_t operator [](uint32_t aIndex) const
      { return GetWaypoint(aIndex); }

};

class Pointcloud3dProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_pointcloud3d_t *mDevice;

  public:
    Pointcloud3dProxy(PlayerClient *aPc, uint32_t aIndex=0);

    ~Pointcloud3dProxy();

    uint32_t GetCount() const { return GetVar(mDevice->points_count); };

    player_pointcloud3d_element_t GetPoint(uint32_t aIndex) const
      { return GetVar(mDevice->points[aIndex]); };

    player_pointcloud3d_element_t operator [] (uint32_t aIndex) const { return GetPoint(aIndex); }

};


class Position1dProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position1d_t *mDevice;

  public:

    Position1dProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~Position1dProxy();

    void SetSpeed(double aVel);

    void GoTo(double aPos, double aVel);

    void RequestGeom();

    player_pose3d_t GetPose() const
    {
      player_pose3d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pyaw = mDevice->pose[2];
      return(p);
    }

    player_bbox3d_t GetSize() const
    {
      player_bbox3d_t b;
      scoped_lock_t lock(mPc->mMutex);
      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }

    void SetMotorEnable(bool enable);

    void SetOdometry(double aPos);

    void ResetOdometry() { SetOdometry(0); };

    //void SetSpeedPID(double kp, double ki, double kd);

    //void SetPositionPID(double kp, double ki, double kd);

    //void SetPositionSpeedProfile(double spd, double acc);

    double  GetPos() const { return GetVar(mDevice->pos); };

    double  GetVel() const { return GetVar(mDevice->vel); };

    bool GetStall() const { return GetVar(mDevice->stall); };

    uint8_t GetStatus() const { return GetVar(mDevice->status); };

    bool IsLimitMin() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_MIN)) > 0; };

    bool IsLimitCen() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_CEN)) > 0; };

    bool IsLimitMax() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_LIMIT_MAX)) > 0; };

    bool IsOverCurrent() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_OC)) > 0; };

    bool IsTrajComplete() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE)) > 0; };

    bool IsEnabled() const
      { return (GetVar(mDevice->status) &
               (1 << PLAYER_POSITION1D_STATUS_ENABLED)) > 0; };

};

class Position2dProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position2d_t *mDevice;

  public:

    Position2dProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~Position2dProxy();

    void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed);

    void SetSpeed(double aXSpeed, double aYawSpeed)
        { return SetSpeed(aXSpeed, 0, aYawSpeed);}

    void SetSpeed(player_pose2d_t vel)
        { return SetSpeed(vel.px, vel.py, vel.pa);}

    void GoTo(player_pose2d_t pos, player_pose2d_t vel);

    void GoTo(player_pose2d_t pos)
      {GoTo(pos,(player_pose2d_t) {0,0,0}); }

    void GoTo(double aX, double aY, double aYaw)
      {GoTo((player_pose2d_t) {aX,aY,aYaw},(player_pose2d_t) {0,0,0}); }

    void SetCarlike(double aXSpeed, double aDriveAngle);

    void RequestGeom();

    //  body (fill it in by calling RequestGeom()).
    player_pose3d_t GetOffset()
    {
      player_pose3d_t p;
      scoped_lock_t lock(mPc->mMutex);
      p.px = mDevice->pose[0];
      p.py = mDevice->pose[1];
      p.pyaw = mDevice->pose[2];
      return(p);
    }

    player_bbox3d_t GetSize()
    {
      player_bbox3d_t b;
      scoped_lock_t lock(mPc->mMutex);
      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }

    void SetMotorEnable(bool enable);

    // Select velocity control mode.
    //
    // For the the p2os_position driver, set @p mode to 0 for direct wheel
    // velocity control (default), or 1 for separate translational and
    // rotational control.
    //
    // For the reb_position driver: 0 is direct velocity control, 1 is for
    // velocity-based heading PD controller (uses DoDesiredHeading()).
    //void SelectVelocityControl(unsigned char mode);

    void ResetOdometry();

    //void SelectPositionMode(unsigned char mode);

    void SetOdometry(double aX, double aY, double aYaw);

    //void SetSpeedPID(double kp, double ki, double kd);

    //void SetPositionPID(double kp, double ki, double kd);

    //void SetPositionSpeedProfile(double spd, double acc);

    //
    // void DoStraightLine(double m);

    //
    //void DoRotation(double yawspeed);

    //
    //void DoDesiredHeading(double yaw, double xspeed, double yawspeed);

    //
    //void SetStatus(uint8_t cmd, uint16_t value);

    //
    //void PlatformShutdown();

    double  GetXPos() const { return GetVar(mDevice->px); };

    double  GetYPos() const { return GetVar(mDevice->py); };

    double GetYaw() const { return GetVar(mDevice->pa); };

    double  GetXSpeed() const { return GetVar(mDevice->vx); };

    double  GetYSpeed() const { return GetVar(mDevice->vy); };

    double  GetYawSpeed() const { return GetVar(mDevice->va); };

    bool GetStall() const { return GetVar(mDevice->stall); };

};

class Position3dProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position3d_t *mDevice;

  public:

    Position3dProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~Position3dProxy();

    void SetSpeed(double aXSpeed, double aYSpeed, double aZSpeed,
                  double aRollSpeed, double aPitchSpeed, double aYawSpeed);

    void SetSpeed(double aXSpeed, double aYSpeed,
                  double aZSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed,aYSpeed,aZSpeed,0,0,aYawSpeed); }

    void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed, aYSpeed, 0, 0, 0, aYawSpeed); }

    void SetSpeed(double aXSpeed, double aYawSpeed)
      { SetSpeed(aXSpeed,0,0,0,0,aYawSpeed);}

    void SetSpeed(player_pose3d_t vel)
      { SetSpeed(vel.px,vel.py,vel.pz,vel.proll,vel.ppitch,vel.pyaw);}

    void GoTo(player_pose3d_t aPos, player_pose3d_t aVel);

    void GoTo(player_pose3d_t aPos)
      { GoTo(aPos, (player_pose3d_t) {0,0,0,0,0,0}); }


    void GoTo(double aX, double aY, double aZ,
              double aRoll, double aPitch, double aYaw)
      { GoTo((player_pose3d_t) {aX,aY,aZ,aRoll,aPitch,aYaw},
              (player_pose3d_t) {0,0,0,0,0,0});
      }

    void SetMotorEnable(bool aEnable);

    void SelectVelocityControl(int aMode);

    void ResetOdometry();

    void SetOdometry(double aX, double aY, double aZ,
                     double aRoll, double aPitch, double aYaw);

    void RequestGeom();

    // Select position mode
    // Set @p mode for 0 for velocity mode, 1 for position mode.
    //void SelectPositionMode(unsigned char mode);

    //
    //void SetSpeedPID(double kp, double ki, double kd);

    //
    //void SetPositionPID(double kp, double ki, double kd);

    // Sets the ramp profile for position based control
    // spd rad/s, acc rad/s/s
    //void SetPositionSpeedProfile(double spd, double acc);

    double  GetXPos() const { return GetVar(mDevice->pos_x); };

    double  GetYPos() const { return GetVar(mDevice->pos_y); };

    double  GetZPos() const { return GetVar(mDevice->pos_z); };

    double  GetRoll() const { return GetVar(mDevice->pos_roll); };

    double  GetPitch() const { return GetVar(mDevice->pos_pitch); };

    double  GetYaw() const { return GetVar(mDevice->pos_yaw); };

    double  GetXSpeed() const { return GetVar(mDevice->vel_x); };

    double  GetYSpeed() const { return GetVar(mDevice->vel_y); };

    double  GetZSpeed() const { return GetVar(mDevice->vel_z); };

    double  GetRollSpeed() const { return GetVar(mDevice->vel_roll); };

    double  GetPitchSpeed() const { return GetVar(mDevice->vel_pitch); };

    double  GetYawSpeed() const { return GetVar(mDevice->vel_yaw); };

    bool GetStall () const { return GetVar(mDevice->stall); };
};
class PowerProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_power_t *mDevice;

  public:
    PowerProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~PowerProxy();

    double GetCharge() const { return GetVar(mDevice->charge); };

    double GetPercent() const {return GetVar(mDevice->percent); };

    double GetJoules() const {return GetVar(mDevice->joules); };

    double GetWatts() const {return GetVar(mDevice->watts); };

    bool GetCharging() const {return GetVar(mDevice->charging);};

    // Return whether the power data is valid
    bool IsValid() const {return GetVar(mDevice->valid);};
};

class PtzProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ptz_t *mDevice;

  public:
    PtzProxy(PlayerClient *aPc, uint32_t aIndex=0);
    // destructor
    ~PtzProxy();

  public:

    void SetCam(double aPan, double aTilt, double aZoom);

    void SetSpeed(double aPanSpeed=0, double aTiltSpeed=0, double aZoomSpeed=0);

    void SelectControlMode(uint32_t aMode);

    double GetPan() const { return GetVar(mDevice->pan); };
    double GetTilt() const { return GetVar(mDevice->tilt); };
    double GetZoom() const { return GetVar(mDevice->zoom); };

    int GetStatus();


};

class RangerProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ranger_t *mDevice;

  public:
    RangerProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~RangerProxy();

    uint32_t GetSensorCount() const { return GetVar(mDevice->sensor_count); };

    player_pose3d_t GetDevicePose() const { return GetVar(mDevice->device_pose); };
    player_bbox3d_t GetDeviceSize() const { return GetVar(mDevice->device_size); };

    player_pose3d_t GetSensorPose(uint32_t aIndex) const;
    player_bbox3d_t GetSensorSize(uint32_t aIndex) const;

    uint32_t GetRangeCount() const { return GetVar(mDevice->ranges_count); };
    double GetRange(uint32_t aIndex) const;
    double operator[] (uint32_t aIndex) const { return GetRange(aIndex); }

    uint32_t GetIntensityCount() const { return GetVar(mDevice->intensities_count); } ;
    double GetIntensity(uint32_t aIndex) const;

    void SetPower(bool aEnable);

    void SetIntensityData(bool aEnable);

    void RequestGeom();

    void Configure(double aMinAngle,
                   double aMaxAngle,
                   double aResolution,
                   double aMaxRange,
                   double aRangeRes,
                   double aFrequency);

    void RequestConfigure();

    double GetMinAngle() const { return GetVar(mDevice->min_angle); };

    double GetMaxAngle() const { return GetVar(mDevice->max_angle); };

    double GetResolution() const { return GetVar(mDevice->resolution); };

    double GetMaxRange() const { return GetVar(mDevice->max_range); };

    double GetRangeRes() const { return GetVar(mDevice->range_res); };

    double GetFrequency() const { return GetVar(mDevice->frequency); };
};

class RFIDProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_rfid_t *mDevice;

  public:
    RFIDProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~RFIDProxy();

    uint32_t GetTagsCount() const { return GetVar(mDevice->tags_count); };
    playerc_rfidtag_t GetRFIDTag(uint32_t aIndex) const
      { return GetVar(mDevice->tags[aIndex]);};

    playerc_rfidtag_t operator [](uint32_t aIndex) const
      { return(GetRFIDTag(aIndex)); }
};

class SimulationProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_simulation_t *mDevice;

  public:
    SimulationProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~SimulationProxy();

    void SetPose2d(char* identifier, double x, double y, double a);

    void GetPose2d(char* identifier, double& x, double& y, double& a);

    void SetPose3d(char* identifier, double x, double y, double z,
                   double roll, double pitch, double yaw);

    void GetPose3d(char* identifier, double& x, double& y, double& z,
                   double& roll, double& pitch, double& yaw, double& time);

    void GetProperty(char* identifier, char *name, void *value, size_t value_len );

    void SetProperty(char* identifier, char *name, void *value, size_t value_len );
};


class SonarProxy : public ClientProxy
{
  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_sonar_t *mDevice;

  public:
    SonarProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~SonarProxy();

    uint32_t GetCount() const { return GetVar(mDevice->scan_count); };

    double GetScan(uint32_t aIndex) const
      { if (GetVar(mDevice->scan_count) <= (int32_t)aIndex) return -1.0; return GetVar(mDevice->scan[aIndex]); };
    double operator [] (uint32_t aIndex) const { return GetScan(aIndex); }

    uint32_t GetPoseCount() const { return GetVar(mDevice->pose_count); };

    player_pose3d_t GetPose(uint32_t aIndex) const
      { return GetVar(mDevice->poses[aIndex]); };

    // Enable/disable the sonars.
    // Set @p state to 1 to enable, 0 to disable.
    // Note that when sonars are disabled the client will still receive sonar
    // data, but the ranges will always be the last value read from the sonars
    // before they were disabled.
    //void SetEnable(bool aEnable);

    void RequestGeom();
};

class SpeechProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_speech_t *mDevice;

  public:
    SpeechProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~SpeechProxy();

    void Say(std::string aStr);
};

class SpeechRecognitionProxy : public ClientProxy
{
   void Subscribe(uint32_t aIndex);
   void Unsubscribe();

   playerc_speechrecognition_t *mDevice;
  public:
   SpeechRecognitionProxy(PlayerClient *aPc, uint32_t aIndex=0);
   ~SpeechRecognitionProxy();
   std::string GetWord(uint32_t aWord) const{
     scoped_lock_t lock(mPc->mMutex);
     return std::string(mDevice->words[aWord]);
   }

   uint32_t GetCount(void) const { return GetVar(mDevice->wordCount); }

   std::string operator [](uint32_t aWord) { return(GetWord(aWord)); }
};

class VectorMapProxy : public ClientProxy
{

  private:

    // Subscribe
    void Subscribe(uint32_t aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_vectormap_t *mDevice;

    bool map_info_cached;
  public:
    // Constructor
    VectorMapProxy(PlayerClient *aPc, uint32_t aIndex=0);
    // Destructor
    ~VectorMapProxy();

    void GetMapInfo();
    void GetLayerData(unsigned layer_index);

    int GetLayerCount() const;
    std::vector<std::string> GetLayerNames() const;
    int GetFeatureCount(unsigned layer_index) const;
    GEOSGeom GetFeatureData(unsigned layer_index, unsigned feature_index) const;
};

class WiFiProxy: public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_wifi_t *mDevice;

  public:
    WiFiProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~WiFiProxy();

    const playerc_wifi_link_t *GetLink(int aLink);

                         int GetLinkCount() const { return mDevice->link_count; };
                         char* GetOwnIP() const { return mDevice->ip; };

                         char* GetLinkIP(int index)  const { return (char*) mDevice->links[index].ip; };
                         char* GetLinkMAC(int index)  const { return (char*) mDevice->links[index].mac; };
                         char* GetLinkESSID(int index)  const { return (char*)mDevice->links[index].essid; };
                         double GetLinkFreq(int index)  const {return mDevice->links[index].freq;};
                         int     GetLinkMode(int index)  const { return mDevice->links[index].mode; };
                         int     GetLinkEncrypt(int index)  const {return mDevice->links[index].encrypt; };
                         int   GetLinkQuality(int index)  const { return mDevice->links[index].qual; };
                         int     GetLinkLevel(int index)  const {return mDevice->links[index].level; };
                         int     GetLinkNoise(int index)  const {return mDevice->links[index].noise; }  ;                

                        //player_wifi_link_t
//     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);
//
//   private:
//     int GetLinkIndex(char *ip);
//
//     /// The current wifi data.
//     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 WSNProxy : public ClientProxy
{

  private:

    void Subscribe(uint32_t aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_wsn_t *mDevice;

  public:
    WSNProxy(PlayerClient *aPc, uint32_t aIndex=0);
    ~WSNProxy();

    uint32_t GetNodeType    () const { return GetVar(mDevice->node_type);      };
    uint32_t GetNodeID      () const { return GetVar(mDevice->node_id);        };
    uint32_t GetNodeParentID() const { return GetVar(mDevice->node_parent_id); };

    player_wsn_node_data_t
       GetNodeDataPacket() const { return GetVar(mDevice->data_packet);    };

    void SetDevState(int nodeID, int groupID, int devNr, int value);
    void Power(int nodeID, int groupID, int value);
    void DataType(int value);
    void DataFreq(int nodeID, int groupID, float frequency);
};

}

namespace std
{
  std::ostream& operator << (std::ostream& os, const player_point_2d_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose2d_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose3d_t& c);
  std::ostream& operator << (std::ostream& os, const player_bbox2d_t& c);
  std::ostream& operator << (std::ostream& os, const player_bbox3d_t& c);
  std::ostream& operator << (std::ostream& os, const player_segment_t& c);
  std::ostream& operator << (std::ostream& os, const player_extent2d_t& c);
  std::ostream& operator << (std::ostream& os, const playerc_device_info_t& c);

  std::ostream& operator << (std::ostream& os, const PlayerCc::ClientProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::ActArrayProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::AioProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::AudioProxy& a);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::BlinkenLightProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::BlobfinderProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::BumperProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::CameraProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::DioProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::FiducialProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::GpsProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::GripperProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::ImuProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::IrProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LaserProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LimbProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LocalizeProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::LogProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::MapProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::OpaqueProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PlannerProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position1dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position2dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::Position3dProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PowerProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::PtzProxy& c);
  std::ostream& operator << (std::ostream &os, const PlayerCc::RangerProxy &c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SimulationProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SonarProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechRecognitionProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::VectorMapProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::WafeformProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::WiFiProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::RFIDProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::WSNProxy& c);
}

#endif

---

Last updated 12 September 2005 21:38:45