Player

• Frontpage
• Contents

User

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

Developer

• Architecture
• libplayercore
  • interfaces
• libplayerdrivers
  • drivers
• libplayererror
• 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
 *
 */

/***************************************************************************
 * Desc: Player v2.0 C++ client
 * Authors: Brad Kratochvil, Toby Collett
 *
 * Date: 23 Sep 2005
 # CVS: $Id: playerc++.h,v 1.46 2006/02/28 05:15:41 gerkey Exp $
 **************************************************************************/


#ifndef PLAYERCC_H
#define PLAYERCC_H

#include <cmath>
#include <string>
#include <list>

#include "libplayerc/playerc.h"
#include "libplayerc++/playerc++config.h"
#include "libplayerc++/playerclient.h"
#include "libplayerc++/playererror.h"


#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
{
// Since they are inline, these functions are as efficient as DEFINES,
// but now they have the benefit of type checking!

inline double rtod(double r)
{
  return r * 180.0 / M_PI;
}

inline double dtor(double r)
{
  return r * M_PI / 180.0;
}

inline double normalize(double z)
{
  return atan2(sin(z), cos(z));
}

template<typename T>
inline T min(T a, T b)
{
  if (a < b)
    return a;
  else
    return b;
}

template<typename T>
inline T max(T a, T b)
{
  if (a > b)
    return a;
  else
    return b;
}

template<typename T>
inline T limit(T a, T min, T max)
{
  if (a < min)
    return min;
  else if (a > max)
    return max;
  else
    return a;
}

class ClientProxy
{
  friend class PlayerClient;

  public:

#ifdef HAVE_BOOST_SIGNALS
    typedef boost::signals::connection connection_t;

    // A scoped lock
    typedef boost::mutex::scoped_lock scoped_lock_t;

    // the function pointer type for read signals signal
    typedef boost::signal<void (void)> read_signal_t;
#else
    // if we're not using boost, just define them.
    typedef int connection_t;
    // we redefine boost::mustex::scoped_lock in playerclient.h
    typedef boost::mutex::scoped_lock scoped_lock_t;
    typedef int read_signal_t;
#endif

  protected:

    // The ClientProxy constructor
    // @attention Potected, so it can only be instantiated by other clients
    //
    // @throw PlayerError Throws a PlayerError if unable to connect to the client
    ClientProxy(PlayerClient* aPc, uint aIndex);

    // destructor will try to close access to the device
    virtual ~ClientProxy();

    // Subscribe to the proxy
    // This needs to be defined for every proxy.
    // @arg aIndex the index of the devce we want to connect to

    // I wish these could be pure virtual,
    // but they're used in the constructor/destructor
    virtual void Subscribe(uint aIndex) {};

    // Unsubscribe from the proxy
    // This needs to be defined for every proxy.
    virtual void Unsubscribe() {};

    // The controlling client object.
    PlayerClient* mPc;

    // A reference to the C client
    playerc_client_t* mClient;

    // contains convenience information about the device
    playerc_device_t *mInfo;

    // if set to true, the current data is "fresh"
    bool mFresh;

    // @brief Get a variable from the client
    // All Get functions need to use this when accessing data from the
    // c library to make sure the data access is thread safe.
    template<typename T>
    T GetVar(const T &aV) const
    { // these have to be defined here since they're templates
      scoped_lock_t lock(mPc->mMutex);
      T v = aV;
      return v;
    }

    // @brief Get a variable from the client by reference
    // All Get functions need to use this when accessing data from the
    // c library to make sure the data access is thread safe.  In this
    // case, a begin, end, and destination pointer must be given (similar
    // to C++ copy).  It is up to the user to ensure there is memory
    // allocated at aDest.
    template<typename T>
    void GetVarByRef(const T aBegin, const T aEnd, T aDest) const
    { // these have to be defined here since they're templates
      scoped_lock_t lock(mPc->mMutex);
      std::copy(aBegin, aEnd, aDest);
    }

  private:

    // The last time that data was read by this client in [s].
    double mLastTime;

    // A boost::signal which is used for our callbacks.
    // The signal will normally be of a type such as:
    // - boost::signal<void ()>
    // - boost::signal<void (T)>
    // where T can be any type.
    //
    // @attention we currently only use signals that return void because we
    // don't have checks to make sure a signal is registered.  If an empty
    // signal is called:
    //
    // @attention "Calling the function call operator may invoke undefined
    // behavior if no slots are connected to the signal, depending on the
    // combiner used. The default combiner is well-defined for zero slots when
    // the return type is void but is undefined when the return type is any
    // other type (because there is no way to synthesize a return value)."
    //
    read_signal_t mReadSignal;

    // Outputs the signal if there is new data
    void ReadSignal();

  public:

    bool IsValid() const { return 0!=GetVar(mInfo->datatime); };

    bool IsFresh() const { return GetVar(mFresh); };

    void NotFresh();

    std::string GetDriverName() const { return mInfo->drivername; };

    double GetDataTime() const { return GetVar(mInfo->datatime); };

    double GetElapsedTime() const
      { return GetVar(mInfo->datatime) - GetVar(mInfo->lasttime); };

    uint GetIndex() const { return GetVar(mInfo->addr.index); };

    uint GetInterface() const { return GetVar(mInfo->addr.interf); };

    std::string GetInterfaceStr() const
      { return playerc_lookup_name(GetVar(mInfo->addr.interf)); };

    template<typename T>
    connection_t ConnectReadSignal(T aSubscriber)
      {
#ifdef HAVE_BOOST_SIGNALS
        scoped_lock_t lock(mPc->mMutex);
        return mReadSignal.connect(aSubscriber);
#else
        return -1;
#endif
      }

    void DisconnectReadSignal(connection_t aSubscriber)
      {
#ifdef HAVE_BOOST_SIGNALS
        scoped_lock_t lock(mPc->mMutex);
        aSubscriber.disconnect();
#endif
      }

};

#if 0

class SomethingProxy : public ClientProxy
{

  private:

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

    // libplayerc data structure
    playerc_something_t *mDevice;

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

};

#endif

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

class ActArrayProxy : public ClientProxy
{
  private:

   void Subscribe(uint aIndex);
   void Unsubscribe();

   // libplayerc data structure
   playerc_actarray_t *mDevice;

  public:

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

    void RequestGeometry(void);

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

    void MoveTo(uint aJoint, float aPos);
    void MoveAtSpeed(uint aJoint, float aSpeed);
    void MoveHome(int aJoint);

    uint GetCount(void) const { return GetVar(mDevice->actuators_count); }
    player_actarray_actuator_t GetActuatorData(uint aJoint) const;
    player_actarray_actuatorgeom_t GetActuatorGeom(uint aJoint) const;

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

class AioProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_aio_t *mDevice;

  public:

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

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

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

    void SetVoltage(uint aIndex, double aVoltage);

    bool operator [](uint aIndex) const
      { return GetVoltage(aIndex); }

};

#if 0 // Not in libplayerc

class AudioProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audio_t *mDevice;

  public:

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

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

    double GetFrequency(uint aIndex) const
      { return(GetVar(mDevice->frequency[aIndex])); };
    double GetAmplitude(uint aIndex) const
      { return(GetVar(mDevice->amplitude[aIndex])); };

    // Play a fixed-frequency tone
    void PlayTone(uint aFreq, uint aAmp, uint aDur);
};

class AudioDspProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audiodsp_t *mDevice;

  public:
    AudioDspProxy(PlayerClient *aPc, uint aIndex=0);
    ~AudioDspProxy

    uint SetFormat(int aFormat);

    uint SetRate(uint aRate);

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

    double GetFrequency(uint aIndex) const
      { return(GetVar(mDevice->frequency[aIndex])); };
    double GetAmplitude(uint aIndex) const
      { return(GetVar(mDevice->amplitude[aIndex])); };

    void Configure(uint aChan, uint aRate, int16_t aFormat=0xFFFFFFFF );

    void RequestConfigure();

    void PlayTone(uint aFreq, uint aAmp, uint aDur);
    void PlayChirp(uint aFreq, uint aAmp, uint aDur,
                   const uint8_t aBitString, uint aBitStringLen);
    void Replay();

    void Print ();
};

class AudioMixerProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_audiodsp_t *mDevice;

  public:

    AudioMixerProxy (PlayerClient *aPc, uint aIndex=0);

    void GetConfigure();

    void SetMaster(uint aLeft, uint aRight);
    void SetPCM(uint aLeft, uint aRight);
    void SetLine(uint aLeft, uint aRight);
    void SetMic(uint aLeft, uint aRight);
    void SetIGain(uint aGain);
    void SetOGain(uint aGain);

};

class BlinkenLightProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blinkenlight_t *mDevice;

  public:
    BlinkenLightProxy(PlayerClient *aPc, uint aIndex=0);
    ~BlinkenLightProxy();

    // true: indicator light enabled, false: disabled.
    bool GetEnable();

    void SetPeriod(double aPeriod);

    void SetEnable(bool aSet);
};

#endif

class BlobfinderProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_blobfinder_t *mDevice;

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

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

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

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

/*
    void SetTrackingColor(uint aReMin=0,   uint aReMax=255, uint aGrMin=0,
                          uint aGrMax=255, uint aBlMin=0,   uint 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(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_bumper_t *mDevice;

  public:

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

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

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

    bool IsAnyBumped();

    void RequestBumperConfig();

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

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

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

};

class CameraProxy : public ClientProxy
{

  private:

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

    // libplayerc data structure
    playerc_camera_t *mDevice;

    std::string mPrefix;
    int mFrameNo;

  public:

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

    virtual ~CameraProxy();

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

    void Decompress();

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

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

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

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

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

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

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

};


class DioProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_dio_t *mDevice;

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

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

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

    void SetOutput(uint aCount, uint32_t aDigout);
};

#if 0 // not libplayerc yet


class EnergyProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_energy_t *mDevice;

public:

    EnergyProxy(PlayerClient *aPc, uint aIndex=0);
    ~EnergyProxy();

    uint GetJoules() const { return GetVar(mDevice->joules); };
    uint GetWatts() const { return GetVar(mDevice->watts); };
    bool GetCharging() const { return GetVar(mDevice->charging); };
};

#endif

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

    // libplayerc data structure
    playerc_fiducial_t *mDevice;

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

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

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

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

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

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

    void RequestGeometry();

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

class GpsProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gps_t *mDevice;

  public:

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

    ~GpsProxy();

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

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

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

    uint 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(uint aIndex);
    // Unsubscribe
    void Unsubscribe();

    // libplayerc data structure
    playerc_graphics2d_t *mDevice;

  public:
    // Constructor
    Graphics2dProxy(PlayerClient *aPc, uint 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 GripperProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_gripper_t *mDevice;

  public:

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

    uint GetState() const { return GetVar(mDevice->state); };
    uint GetBeams() const { return GetVar(mDevice->beams); };
    uint GetOuterBreakBeam() const
      { return GetVar(mDevice->outer_break_beam); };
    uint GetInnerBreakBeam() const
      { return GetVar(mDevice->inner_break_beam); };
    uint GetPaddlesOpen() const
      { return GetVar(mDevice->paddles_open); };
    uint GetPaddlesClosed() const
      { return GetVar(mDevice->paddles_closed); };
    uint GetPaddlesMoving() const
      { return GetVar(mDevice->paddles_moving); };
    uint GetGripperError() const
      { return GetVar(mDevice->gripper_error); };
    uint GetLiftUp() const { return GetVar(mDevice->lift_up); };
    uint GetLiftDown() const { return GetVar(mDevice->lift_down); };
    uint GetLiftMoving() const { return GetVar(mDevice->lift_moving); };
    uint GetLiftError() const { return GetVar(mDevice->lift_error); };

    void SetGrip(uint8_t aCmd, uint8_t aArg=0);
};



class IrProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ir_t *mDevice;

  public:

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

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

    void RequestGeom();

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

};

class LaserProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_laser_t *mDevice;

    double aMinLeft;
    double aMinRight;

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

  public:

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

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

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

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


    double GetMaxAngle() const { return GetVar(mDevice->scan_start); };
    double GetMinAngle() const { return GetVar(mDevice->scan_start) + GetVar(mDevice->scan_count)*GetVar(mDevice->scan_res); };

/*    /// Whether or not reflectance (i.e., intensity) values are being returned.
    bool IsIntensity() const { return GetVar(mDevice->intensity); };

    double GetScan(uint aIndex) const
      { return GetVar(mDevice->scan[aIndex]); };
*/
    player_point_2d_t GetPoint(uint aIndex) const
      { return GetVar(mDevice->point[aIndex]); };


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

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

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

    void RequestConfigure();

    void RequestGeom();

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

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

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

      b.sl = mDevice->size[0];
      b.sw = mDevice->size[1];
      return(b);
    }

    double MinLeft () { return aMinLeft; }
    double MinRight () { return aMinRight; }

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

};

class LimbProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

   // libplayerc data structure
    playerc_limb_t *mDevice;

  public:

    LimbProxy(PlayerClient *aPc, uint 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(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_localize_t *mDevice;

  public:

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

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

    // @todo should these be in a player_pose_t?
    uint GetMapTileX() const { return GetVar(mDevice->map_tile_x); };
    uint 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);
    //};

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

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

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

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

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

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

class LogProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_log_t *mDevice;

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

    ~LogProxy();

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

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

    void SetWriteState(int aState);

    void SetReadState(int aState);

    void Rewind();

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

class MapProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_map_t *mDevice;

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

    ~MapProxy();

    void RequestMap();

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

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

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

    uint GetWidth() const { return GetVar(mDevice->width); };
    uint 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);
    };
};

#if 0

class McomProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_mcom_t *mDevice;

    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();
};

#endif

class PlannerProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_planner_t *mDevice;

  public:

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

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

    void RequestWaypoints();

    void SetEnable(bool aEnable);

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

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

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

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

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

    uint GetCurrentWaypoint() const
      { return GetVar(mDevice->curr_waypoint); };

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

    // Get a waypoints in the current plan (m,m,radians).
    //uint GetWaypoint(uint aIndex) const
    //  { return GetVar(mDevice->waypoints[aIndex]); };

};

class Position2dProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position2d_t *mDevice;

  public:

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

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

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

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

    void SetCarlike(double aXSpeed, double aDriveAngle);

    void RequestGeom();

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

    player_bbox_t GetSize()
    {
      player_bbox_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 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(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_position3d_t *mDevice;

  public:

    Position3dProxy(PlayerClient *aPc, uint 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 GoTo(double aX, double aY, double aZ,
              double aRoll, double aPitch, double aYaw);

    void SetMotorEnable(bool aEnable);

    //void SelectVelocityControl(unsigned char mode);

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

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

    //void SelectPositionMode(unsigned char mode);

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

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

    //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(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_power_t *mDevice;

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

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

};

class PtzProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_ptz_t *mDevice;

  public:
    PtzProxy(PlayerClient *aPc, uint 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(uint aMode);

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

};

class SimulationProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_simulation_t *mDevice;

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

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

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


class SonarProxy : public ClientProxy
{
  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_sonar_t *mDevice;

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

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

    double GetScan(uint aIndex) const
      { return GetVar(mDevice->scan[aIndex]); };
    double operator [] (uint aIndex) const { return GetScan(aIndex); }

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

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

    //void SetEnable(bool aEnable);

    void RequestGeom();
};

#if 0

class SoundProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_sound_t *mDevice;

  public:
    // Constructor
    SoundProxy(PlayerClient *aPc, uint aIndex=0);

    ~SoundProxy();

    void Play(int aIndex);
};
#endif

class SpeechProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_speech_t *mDevice;

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

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

#if 0

class SpeechRecognitionProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_speech_t *mDevice;

  public:
    // Constructor
    SpeechRecognitionProxy(PlayerClient *aPc, uint aIndex=0);

    ~SpeechRecognitionProxy();

  std::string GetText();

};
#endif

#if 0

class TruthProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_truth_t *mDevice;

  public:
    TruthProxy(PlayerClient *aPc, uint aIndex=0);
    ~TruthProxy();

    double GetX() const { return GetVar(mDevice->pos[0]); };
    double GetY() const { return GetVar(mDevice->pos[1]); };
    double GetZ() const { return GetVar(mDevice->pos[2]); };
    double GetRoll() const { return GetVar(mDevice->rot[0]); };
    double GetPitch() const { return GetVar(mDevice->rot[1]); };
    double GetYaw() const { return GetVar(mDevice->rot[2]); };

    void GetPose(double *px, double *py, double *pz,
                 double *rx, double *ry, double *rz);

    void SetPose(double px, double py, double pz,
                 double rx, double ry, double rz);

    void SetPoseOnRoot(double px, double py, double pz,
                       double rx, double ry, double rz);

    uint GetFiducialID();

    void SetFiducialID(int16_t id);

};
class WaveformProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_waveform_t *mDevice;

  public:
    // Constructor
    WaveformProxy(PlayerClient *aPc, uint aIndex=0);

    ~WaveformProxy();

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

    uint GetBitRate() const { return GetVar(mDevice->rate); };

    uint GetDepth() const { return GetVar(mDevice->depth); };

    void GetImage(uint8_t* aBuffer) const
    {
      return GetVarByRef(mDevice->data,
                         mDevice->data+GetCount(),
                         aBuffer);
    };

    // dsp file descriptor
    //uint GetFd() const { return GetVar(mDevice->fd); };

    // set up the DSP to the current bitrate and depth
    void ConfigureDSP(uint aBitRate, uint aDepth);

    // open the sound device
    void OpenDSPforWrite();

    // Play the waveform through the DSP
    void Play();
};
#endif

class WiFiProxy: public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_wifi_t *mDevice;

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

#if 0

    int GetLinkQuality(char
    int GetLevel(char
    int GetLeveldBm(char
    int GetNoise(char
    int GetNoisedBm(char

    uint16_t GetMaxLinkQuality() { return maxqual; }
    uint8_t GetMode() { return op_mode; }

    int GetBitrate();

    char

    char
    char

    int AddSpyHost(char *address);
    int RemoveSpyHost(char *address);

  private:
    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];
#endif
};
class RFIDProxy : public ClientProxy
{

  private:

    void Subscribe(uint aIndex);
    void Unsubscribe();

    // libplayerc data structure
    playerc_rfid_t *mDevice;

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

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

    playerc_rfidtag_t operator [](uint aIndex) const
      { return(GetRFIDTag(aIndex)); }
};
} // namespace PlayerCc


namespace std
{
  std::ostream& operator << (std::ostream& os, const player_point_2d_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose_t& c);
  std::ostream& operator << (std::ostream& os, const player_pose3d_t& c);
  std::ostream& operator << (std::ostream& os, const player_bbox_t& c);
  std::ostream& operator << (std::ostream& os, const player_segment_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::AudioDspProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::AudioMixerProxy& c);
  //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::EnergyProxy& 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::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::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::SimulationProxy& c);
  std::ostream& operator << (std::ostream& os, const PlayerCc::SonarProxy& c);
  //std::ostream& operator << (std::ostream& os, const PlayerCc::SoundProxy& 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::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::TruthProxy& c);
}
#endif

---

Last updated 12 September 2005 21:38:45