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 8173 2009-08-04 07:25:00Z gbiggs $
**************************************************************************/
#ifndef PLAYERCC_H
#define PLAYERCC_H
#include <cstddef>
#include <cmath>
#include <string>
#include <list>
#include <vector>
#include <cstring>
#include "libplayerc/playerc.h"
#include "libplayerc++/utility.h"
#include "libplayerc++/playerclient.h"
#include "libplayerc++/playererror.h"
#include "libplayerc++/clientproxy.h"
#include "libplayerinterface/interface_util.h"
#if defined (WIN32)
#if defined (PLAYER_STATIC)
#define PLAYERCC_EXPORT
#elif defined (playerc___EXPORTS)
#define PLAYERCC_EXPORT __declspec (dllexport)
#else
#define PLAYERCC_EXPORT __declspec (dllimport)
#endif
#else
#define PLAYERCC_EXPORT
#endif
// 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT BlackBoardProxy : public ClientProxy
{
private:
void Subscribe(uint32_t aIndex);
void Unsubscribe();
// libplayerc data structure
playerc_blackboard_t *mDevice;
public:
BlackBoardProxy(PlayerClient *aPc, uint32_t 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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) != 0 ? true : false; }
};
class PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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) != 0 ? true : false; };
// /// 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT LinuxjoystickProxy : public ClientProxy
{
private:
void Subscribe(uint32_t aIndex);
void Unsubscribe();
// libplayerc data structure
playerc_joystick_t *mDevice;
public:
LinuxjoystickProxy(PlayerClient *aPc, uint32_t aIndex=0);
~LinuxjoystickProxy();
uint32_t GetButtons() const { return GetVar(mDevice->buttons); };
double GetAxes(uint32_t aIndex) const
{ if (GetVar(mDevice->axes_count) <= (int32_t)aIndex) return -1.0; return GetVar(mDevice->pos[aIndex]); };
double operator [] (uint32_t aIndex) const { return GetAxes(aIndex); }
uint32_t GetAxesCount() const { return GetVar(mDevice->axes_count); };
// player_pose3d_t GetPose(uint32_t aIndex) const
// { return GetVar(mDevice->poses[aIndex]); };
// Enable/disable the joysticks.
// Set @p state to 1 to enable, 0 to disable.
// Note that when joysticks are disabled the client will still receive joystick
// data, but the ranges will always be the last value read from the joysticks
// before they were disabled.
//void SetEnable(bool aEnable);
// void RequestGeom();
};
class PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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) != 0 ? true : false; };
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 PLAYERCC_EXPORT 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 SetVelHead(double aXSpeed, double aYSpeed, double aYawHead);
void SetVelHead(double aXSpeed, double aYawHead)
{ return SetVelHead(aXSpeed, 0, aYawHead);}
void GoTo(player_pose2d_t pos, player_pose2d_t vel);
void GoTo(player_pose2d_t pos)
{ player_pose2d_t vel = {0,0,0}; GoTo(pos, vel); }
void GoTo(double aX, double aY, double aYaw)
{ player_pose2d_t pos = {aX,aY,aYaw}; player_pose2d_t vel = {0,0,0}; GoTo(pos, vel); }
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) != 0 ? true : false; };
};
class PLAYERCC_EXPORT 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)
{ player_pose3d_t vel = {0,0,0,0,0,0}; GoTo(aPos, vel); }
void GoTo(double aX, double aY, double aZ,
double aRoll, double aPitch, double aYaw)
{ player_pose3d_t pos = {aX,aY,aZ,aRoll,aPitch,aYaw};
player_pose3d_t vel = {0,0,0,0,0,0};
GoTo(pos, vel);
}
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) != 0 ? true : false; };
};
class PLAYERCC_EXPORT 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) != 0 ? true : false;};
// Return whether the power data is valid
bool IsValid() const {return GetVar(mDevice->valid) != 0 ? true : false;};
};
class PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 GetElementCount() const { return GetVar(mDevice->element_count); };
player_pose3d_t GetDevicePose() const { return GetVar(mDevice->device_pose); };
player_bbox3d_t GetDeviceSize() const { return GetVar(mDevice->device_size); };
player_pose3d_t GetElementPose(uint32_t aIndex) const;
player_bbox3d_t GetElementSize(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 aAngularRes,
double aMinRange,
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 GetAngularRes() const { return GetVar(mDevice->angular_res); };
double GetMinRange() const { return GetVar(mDevice->min_range); };
double GetMaxRange() const { return GetVar(mDevice->max_range); };
double GetRangeRes() const { return GetVar(mDevice->range_res); };
double GetFrequency() const { return GetVar(mDevice->frequency); };
};
class PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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;
const uint8_t * GetFeatureData(unsigned layer_index, unsigned feature_index) const;
size_t GetFeatureDataCount(unsigned layer_index, unsigned feature_index) const;
};
class PLAYERCC_EXPORT 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 PLAYERCC_EXPORT 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
{
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_point_2d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_pose2d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_pose3d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_bbox2d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_bbox3d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_segment_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_extent2d_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const playerc_device_info_t& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ClientProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ActArrayProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::AioProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::AudioProxy& a);
//PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::BlinkenLightProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::BlobfinderProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::BumperProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::CameraProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::DioProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::FiducialProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::GpsProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::GripperProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ImuProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::IrProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LaserProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LimbProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LinuxjoystickProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LocalizeProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LogProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::MapProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::OpaqueProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PlannerProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position1dProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position2dProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position3dProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PowerProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PtzProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream &os, const PlayerCc::RangerProxy &c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SimulationProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SonarProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechRecognitionProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::VectorMapProxy& c);
//PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::WafeformProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::WiFiProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::RFIDProxy& c);
PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::WSNProxy& c);
}
#endif
PlayerCc::GripperProxy::GetOuterSize
player_bbox3d_t GetOuterSize() const
Get the outer size of the gripper.
Definition: playerc++.h:847
playerc_fiducial_t
Fiducial finder data.
Definition: playerc.h:1510
PlayerCc::LaserProxy::GetBearing
double GetBearing(uint32_t aIndex) const
get the bearing
Definition: playerc++.h:1093
player_wsn_node_data
Structure describing the WSN node's data packet.
Definition: player_interfaces.h:4335
PlayerCc::PlannerProxy
The PlannerProxy proxy provides an interface to a 2D motion planner.
Definition: playerc++.h:1514
playerc_opaque_t
Opaque device data.
Definition: playerc.h:2459
PlayerCc::LogProxy::GetState
int GetState() const
Is logging/playback enabled? Call QueryState() to fill it.
Definition: playerc++.h:1394
PlayerCc::GripperProxy::GetBeams
uint32_t GetBeams() const
Get the gripper break beam info.
Definition: playerc++.h:843
playerc_planner_t
Planner device data.
Definition: playerc.h:2508
PlayerCc::AudioProxy
The AudioProxy class controls an audio device.
Definition: playerc++.h:245
PlayerCc::IrProxy::GetPose
player_pose3d_t GetPose(uint32_t aIndex) const
get a particular pose
Definition: playerc++.h:1006
playerc_ir_t
Ir proxy data.
Definition: playerc.h:1865
playerc_rfid_t
RFID proxy data.
Definition: playerc.h:3433
playerc_aio_t
Aio proxy data.
Definition: playerc.h:929
PlayerCc::MapProxy::GetResolution
double GetResolution() const
Map resolution, m/cell.
Definition: playerc++.h:1448
PlayerCc::IrProxy::GetPoseCount
uint32_t GetPoseCount() const
get the number of poses
Definition: playerc++.h:1004
player_opaque_data
data
Definition: player_interfaces.h:3414
PlayerCc::LaserProxy::GetSize
player_bbox3d_t GetSize()
Accessor for the size (fill it in by calling RequestGeom)
Definition: playerc++.h:1159
PlayerCc::Position3dProxy::GetYaw
double GetYaw() const
Accessor method.
Definition: playerc++.h:2098
PlayerCc::SonarProxy::GetPose
player_pose3d_t GetPose(uint32_t aIndex) const
Sonar poses (m,m,radians)
Definition: playerc++.h:2414
PlayerCc::MapProxy::GetHeight
uint32_t GetHeight() const
Map size, in cells.
Definition: playerc++.h:1455
playerc_vectormap_t
Vectormap proxy.
Definition: playerc.h:2398
player_pose3d::ppitch
double ppitch
pitch [rad]
Definition: player.h:235
PlayerCc::SimulationProxy
The SimulationProxy proxy provides access to a simulation device.
Definition: playerc++.h:2337
player_blackboard_entry
Vectormap feature data.
Definition: player.h:261
player_bbox3d
A rectangular bounding box, used to define the size of an object.
Definition: player.h:250
PlayerCc::Position2dProxy::SetSpeed
void SetSpeed(player_pose2d_t vel)
Overloaded SetSpeed that takes player_pose2d_t as an argument.
Definition: playerc++.h:1844
PlayerCc::LaserProxy::MinRight
double MinRight() const
Definition: playerc++.h:1182
player_imu_data_calib
Data: calibrated IMU data (PLAYER_IMU_DATA_CALIB)
Definition: player_interfaces.h:4670
PlayerCc::BlobfinderProxy::GetHeight
uint32_t GetHeight() const
get the height of the image
Definition: playerc++.h:444
PlayerCc::LocalizeProxy::GetNumHypoths
uint32_t GetNumHypoths() const
Get the number of localization hypoths.
Definition: playerc++.h:1361
playerc_wsn_t
Note: the structure describing the WSN node's data packet is declared in Player.
Definition: playerc.h:3610
PlayerCc::LimbProxy
The LimbProxy class is used to control a limb device.
Definition: playerc++.h:1199
PlayerCc::RangerProxy::GetDeviceSize
player_bbox3d_t GetDeviceSize() const
Return the device size.
Definition: playerc++.h:2232
PlayerCc::LaserProxy::GetMaxRange
double GetMaxRange() const
Max range for the latest set of data (meters)
Definition: playerc++.h:1051
PlayerCc::GpsProxy
The GpsProxy class is used to control a gps device.
Definition: playerc++.h:679
playerc_rfidtag_t
Structure describing a single RFID tag.
Definition: playerc.h:3422
player_extent2d
A rectangular bounding box, used to define the origin and bounds of an object.
Definition: player.h:303
playerc_wifi_link_t
Individual link info.
Definition: playerc.h:3202
PlayerCc::LaserProxy::GetIntensity
int GetIntensity(uint32_t aIndex) const
get the intensity
Definition: playerc++.h:1098
PlayerCc::ActArrayProxy::GetBaseOrientation
player_orientation_3d_t GetBaseOrientation(void) const
Accessor method for getting the base orientation.
Definition: playerc++.h:193
PlayerCc::OpaqueProxy::GetData
void GetData(uint8_t *aDest) const
Opaque data.
Definition: playerc++.h:1496
playerc_localize_t
Localization device data.
Definition: playerc.h:2213
player_audio_seq_item
Player audio sequence item.
Definition: player_interfaces.h:1484
PlayerCc::FiducialProxy::GetSensorPose
player_pose3d_t GetSensorPose() const
The pose of the sensor.
Definition: playerc++.h:654
PlayerCc::AudioProxy::GetChannel
player_audio_mixer_channel_t GetChannel(int aIndex) const
Get Sequence item.
Definition: playerc++.h:291
player_color
A color descriptor.
Definition: player.h:316
PlayerCc::Position3dProxy::SetSpeed
void SetSpeed(player_pose3d_t vel)
Overloaded SetSpeed that takes player_pose3d_t as input.
Definition: playerc++.h:2023
PlayerCc::Position3dProxy
The Position3dProxy class is used to control a interface_position3d device.
Definition: playerc++.h:1982
player_actarray_actuatorgeom
Actuator geometry.
Definition: player_interfaces.h:3786
PlayerCc::Position3dProxy::GetXPos
double GetXPos() const
Accessor method.
Definition: playerc++.h:2083
PlayerCc::AudioProxy::GetDefaultOutputChannel
uint32_t GetDefaultOutputChannel() const
Get Default output Channel.
Definition: playerc++.h:266
PlayerCc::RangerProxy::GetMaxRange
double GetMaxRange() const
Maximum detectable range of a scan (configured value)
Definition: playerc++.h:2291
PlayerCc::Position3dProxy::SetSpeed
void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed)
simplified version of SetSpeed
Definition: playerc++.h:2014
PlayerCc::Position2dProxy::GetStall
bool GetStall() const
Accessor method.
Definition: playerc++.h:1972
playerc_pointcloud3d_t
pointcloud3d proxy data.
Definition: playerc.h:3474
PlayerCc::RangerProxy
The RangerProxy class is used to control a ranger device.
Definition: playerc++.h:2210
PlayerCc::GripperProxy::GetNumBeams
uint32_t GetNumBeams() const
Get the number of breakbeams in the gripper.
Definition: playerc++.h:851
PlayerCc::GpsProxy::GetUtmEasting
double GetUtmEasting() const
UTM easting and northing (meters).
Definition: playerc++.h:717
playerc_camera_t
Camera proxy data.
Definition: playerc.h:1395
PlayerCc::AioProxy::GetVoltage
double GetVoltage(uint32_t aIndex) const
Accessor function.
Definition: playerc++.h:226
PlayerCc::MapProxy::GetCellIndex
int GetCellIndex(int x, int y) const
Return the index of the (x,y) item in the cell array.
Definition: playerc++.h:1440
PlayerCc::Position2dProxy::GetYSpeed
double GetYSpeed() const
Accessor method.
Definition: playerc++.h:1966
PlayerCc::VectorMapProxy
The VectorMapProxy class is used to interface to a vectormap.
Definition: playerc++.h:2485
player_pose2d::px
double px
X [m].
Definition: player.h:216
PlayerCc::AudioProxy::GetState
uint32_t GetState(void) const
Get driver state.
Definition: playerc++.h:293
PlayerCc::PowerProxy::GetCharging
bool GetCharging() const
Returns whether charging is taking place.
Definition: playerc++.h:2152
PlayerCc::PlannerProxy::GetGa
double GetGa() const
Goal location (radians)
Definition: playerc++.h:1578
PlayerCc::Position2dProxy::SetSpeed
void SetSpeed(double aXSpeed, double aYawSpeed)
Same as the previous SetSpeed(), but doesn't take the yspeed speed (so use this one for non-holonomic...
Definition: playerc++.h:1840
PlayerCc::MapProxy
The map proxy provides access to a map device.
Definition: playerc++.h:1419
playerc_simulation_t
Simulation device proxy.
Definition: playerc.h:3272
playerc_speechrecognition_t
Speech recognition proxy data.
Definition: playerc.h:3384
PlayerCc::Position1dProxy::GetVel
double GetVel() const
Accessor method.
Definition: playerc++.h:1771
PlayerCc::AudioProxy::GetMixerDetails
player_audio_mixer_channel_detail_t GetMixerDetails(int aIndex) const
Get Mixer Detail.
Definition: playerc++.h:264
PLAYER_POSITION1D_STATUS_LIMIT_MIN
#define PLAYER_POSITION1D_STATUS_LIMIT_MIN
Status byte: limit min.
Definition: player_interfaces.h:3491
PlayerCc::GripperProxy::GetCapacity
uint32_t GetCapacity() const
Get the capacity of the gripper's storage.
Definition: playerc++.h:853
PlayerCc::PlannerProxy::GetWx
double GetWx() const
Current waypoint location (m)
Definition: playerc++.h:1593
player_pose3d::py
double py
Y [m].
Definition: player.h:229
PLAYER_POSITION1D_STATUS_LIMIT_MAX
#define PLAYER_POSITION1D_STATUS_LIMIT_MAX
Status byte: limit max.
Definition: player_interfaces.h:3495
PlayerCc::GpsProxy::GetVdop
double GetVdop() const
Vertical dilution of position (HDOP)
Definition: playerc++.h:714
PlayerCc::PowerProxy::GetWatts
double GetWatts() const
Returns the watts.
Definition: playerc++.h:2149
PlayerCc::LaserProxy::GetConfMinAngle
double GetConfMinAngle() const
Scan range from the laser config (call RequestConfigure first) (radians)
Definition: playerc++.h:1072
player_pose2d
A pose in the plane.
Definition: player.h:213
PlayerCc::IrProxy::GetVoltage
double GetVoltage(uint32_t aIndex) const
get the current voltage
Definition: playerc++.h:1001
PlayerCc::Position1dProxy::GetStatus
uint8_t GetStatus() const
Accessor method.
Definition: playerc++.h:1777
PlayerCc::GpsProxy::GetLatitude
double GetLatitude() const
Latitude and longitude, in degrees.
Definition: playerc++.h:698
PlayerCc::Position1dProxy::IsTrajComplete
bool IsTrajComplete() const
Accessor method.
Definition: playerc++.h:1800
PlayerCc::HealthProxy
The HealthProxy class is used to get infos of the player-server.
Definition: playerc++.h:871
PlayerCc::LaserProxy::GetScanningFrequency
double GetScanningFrequency() const
Scanning Frequency (Hz)
Definition: playerc++.h:1060
PlayerCc::PlannerProxy::GetPathValid
uint32_t GetPathValid() const
Did the planner find a valid path?
Definition: playerc++.h:1544
PlayerCc::Position1dProxy::IsLimitMin
bool IsLimitMin() const
Accessor method.
Definition: playerc++.h:1780
PlayerCc::PlannerProxy::GetPa
double GetPa() const
Current pose (radians)
Definition: playerc++.h:1557
playerc_graphics3d_t
Graphics3d device data.
Definition: playerc.h:1685
PlayerCc::Position3dProxy::GetXSpeed
double GetXSpeed() const
Accessor method.
Definition: playerc++.h:2101
PlayerCc::FiducialProxy::GetFiducialSize
player_bbox2d_t GetFiducialSize() const
The size of the most recently detected fiducial.
Definition: playerc++.h:662
PlayerCc::ActArrayProxy::GetBasePos
player_point_3d_t GetBasePos(void) const
Accessor method for getting the base position.
Definition: playerc++.h:191
PlayerCc::LocalizeProxy::GetNumParticles
uint32_t GetNumParticles() const
Get the number of particles (for particle filter-based localization systems).
Definition: playerc++.h:1365
PlayerCc::LocalizeProxy::GetHypothCount
uint32_t GetHypothCount() const
Number of possible poses.
Definition: playerc++.h:1344
player_orientation_3d
An angle in 3D space.
Definition: player.h:202
playerc_power_t
Power device data.
Definition: playerc.h:2880
PlayerCc::AudioProxy::GetWavDataLength
uint32_t GetWavDataLength() const
Get Wav data length.
Definition: playerc++.h:271
PlayerCc::LinuxjoystickProxy::GetAxes
double GetAxes(uint32_t aIndex) const
return a particular scan value
Definition: playerc++.h:1271
PlayerCc::Pointcloud3dProxy
The Pointcloud3d proxy provides an interface to a pointcloud3d device.
Definition: playerc++.h:1656
PlayerCc::RangerProxy::GetRangeRes
double GetRangeRes() const
Linear resolution (configured value)
Definition: playerc++.h:2294
PlayerCc::CameraProxy::GetImage
void GetImage(uint8_t *aImage) const
Image data This function copies the image data into the data buffer aImage.
Definition: playerc++.h:570
PlayerCc::GripperProxy
The GripperProxy class is used to control a gripper device.
Definition: playerc++.h:818
PlayerCc::OpaqueProxy
The OpaqueProxy proxy provides an interface to a generic opaque.
Definition: playerc++.h:1474
PlayerCc::PlannerProxy::GetWaypointCount
uint32_t GetWaypointCount() const
Number of waypoints in the plan.
Definition: playerc++.h:1641
PlayerCc::PowerProxy::GetPercent
double GetPercent() const
Returns the percent of power.
Definition: playerc++.h:2143
PlayerCc::Position1dProxy::IsEnabled
bool IsEnabled() const
Accessor method.
Definition: playerc++.h:1805
PlayerCc::Position2dProxy::GoTo
void GoTo(player_pose2d_t pos)
Same as the previous GoTo(), but doesn't take speed.
Definition: playerc++.h:1864
PlayerCc::LaserProxy::GetScanRes
double GetScanRes() const
Angular resolution of scan (radians)
Definition: playerc++.h:1054
playerc_gripper_t
Gripper device data.
Definition: playerc.h:1741
PlayerCc::Position3dProxy::GetZSpeed
double GetZSpeed() const
Accessor method.
Definition: playerc++.h:2107
PlayerCc::BlackBoardProxy
The BlackBoardProxy class is used to subscribe to a blackboard device.
Definition: playerc++.h:346
player_limb_data
Data: state (PLAYER_LIMB_DATA)
Definition: player_interfaces.h:4037
player_actarray_actuator
Structure containing a single actuator's information.
Definition: player_interfaces.h:3758
playerc_map_t
Map proxy data.
Definition: playerc.h:2341
PlayerCc::LocalizeProxy::GetPendingCount
uint32_t GetPendingCount() const
Number of pending (unprocessed) sensor readings.
Definition: playerc++.h:1341
player_limb_geom_req
Request/reply: get geometry.
Definition: player_interfaces.h:4112
PlayerCc::RangerProxy::GetFrequency
double GetFrequency() const
Scanning frequency (configured value)
Definition: playerc++.h:2297
PlayerCc::RangerProxy::GetMinRange
double GetMinRange() const
Minimum detectable range of a scan (configured value)
Definition: playerc++.h:2288
PlayerCc::BumperProxy::IsBumped
uint32_t IsBumped(uint32_t aIndex) const
Returns true if the specified bumper has been bumped, false otherwise.
Definition: playerc++.h:489
PlayerCc::Position2dProxy
The Position2dProxy class is used to control a position2d device.
Definition: playerc++.h:1815
PlayerCc::Position2dProxy::GetXSpeed
double GetXSpeed() const
Accessor method.
Definition: playerc++.h:1963
playerc_position3d_t
Position3d device data.
Definition: playerc.h:2776
playerc_device_info_t
Info about an available (but not necessarily subscribed) device.
Definition: playerc.h:448
PlayerCc::PtzProxy
The PtzProxy class is used to control a ptz device.
Definition: playerc++.h:2164
PlayerCc::RangerProxy::GetMaxAngle
double GetMaxAngle() const
Stop angle of a scan (configured value)
Definition: playerc++.h:2282
player_point_2d
A point in the plane.
Definition: player.h:180
PlayerCc::PlannerProxy::GetCurrentWaypointId
int GetCurrentWaypointId() const
Current waypoint index (handy if you already have the list of waypoints).
Definition: playerc++.h:1637
PlayerCc::PowerProxy::GetJoules
double GetJoules() const
Returns the joules.
Definition: playerc++.h:2146
playerc_ranger_t
Ranger proxy data.
Definition: playerc.h:3019
PlayerCc::Position1dProxy::GetStall
bool GetStall() const
Accessor method.
Definition: playerc++.h:1774
PlayerCc::LaserProxy::GetMinLeft
double GetMinLeft() const
Minimum range reading on the left side.
Definition: playerc++.h:1170
PlayerCc::LaserProxy::GetRange
double GetRange(uint32_t aIndex) const
get the range
Definition: playerc++.h:1089
PlayerCc::LaserProxy::GetCount
uint32_t GetCount() const
Number of points in scan.
Definition: playerc++.h:1048
PlayerCc::Position3dProxy::GetYPos
double GetYPos() const
Accessor method.
Definition: playerc++.h:2086
PlayerCc::PlayerClient
The PlayerClient is used for communicating with the player server.
Definition: playerclient.h:115
PlayerCc::PowerProxy::GetCharge
double GetCharge() const
Returns the current charge.
Definition: playerc++.h:2140
PlayerCc::PlannerProxy::GetGoal
player_pose2d_t GetGoal() const
Get the goal.
Definition: playerc++.h:1581
PlayerCc::Position1dProxy::IsOverCurrent
bool IsOverCurrent() const
Accessor method.
Definition: playerc++.h:1795
PlayerCc::SpeechProxy
The SpeechProxy class is used to control a speech device.
Definition: playerc++.h:2432
player_bbox3d::sw
double sw
Width [m].
Definition: player.h:253
PlayerCc::PlannerProxy::GetWa
double GetWa() const
Current waypoint location (rad)
Definition: playerc++.h:1599
PlayerCc::ClientProxy
The client proxy base class.
Definition: clientproxy.h:79
PlayerCc::RangerProxy::GetMinAngle
double GetMinAngle() const
Start angle of a scan (configured value)
Definition: playerc++.h:2279
PlayerCc::RangerProxy::GetDevicePose
player_pose3d_t GetDevicePose() const
Return the device pose.
Definition: playerc++.h:2230
PlayerCc::ImuProxy
The ImuProxy class is used to control an imu device.
Definition: playerc++.h:931
player_pose3d::px
double px
X [m].
Definition: player.h:227
PlayerCc::LocalizeProxy::GetParticles
int GetParticles()
Get the particle set.
Definition: playerc++.h:1351
PlayerCc::Position2dProxy::SetVelHead
void SetVelHead(double aXSpeed, double aYawHead)
Same as the previous SetVelHead(), but doesn't take the yspeed speed (so use this one for non-holonom...
Definition: playerc++.h:1854
PlayerCc::GpsProxy::GetTime
double GetTime() const
Time, since the epoch.
Definition: playerc++.h:721
PlayerCc::WiFiProxy
The WiFiProxy class controls a wifi device.
Definition: playerc++.h:2517
PlayerCc::Position2dProxy::GetYPos
double GetYPos() const
Accessor method.
Definition: playerc++.h:1957
PlayerCc::LinuxjoystickProxy::GetAxesCount
uint32_t GetAxesCount() const
Number of valid joystick poses.
Definition: playerc++.h:1278
playerc_ptz_t
PTZ device data.
Definition: playerc.h:2937
PlayerCc::PlannerProxy::GetPose
player_pose2d_t GetPose() const
Get the current pose.
Definition: playerc++.h:1560
PlayerCc::Position3dProxy::GetZPos
double GetZPos() const
Accessor method.
Definition: playerc++.h:2089
PlayerCc::PlannerProxy::GetGy
double GetGy() const
Goal location (m)
Definition: playerc++.h:1575
player_pose2d::pa
double pa
yaw [rad]
Definition: player.h:220
PlayerCc::Position3dProxy::GoTo
void GoTo(player_pose3d_t aPos)
Same as the previous GoTo(), but does'n take vel argument.
Definition: playerc++.h:2032
player_audio_seq
Player audio sequence.
Definition: player_interfaces.h:1502
PlayerCc::RangerProxy::GetElementCount
uint32_t GetElementCount() const
Return the individual range sensor count.
Definition: playerc++.h:2227
PlayerCc::BlobfinderProxy::GetWidth
uint32_t GetWidth() const
get the width of the image
Definition: playerc++.h:442
PlayerCc::FiducialProxy::GetFiducialItem
player_fiducial_item_t GetFiducialItem(uint32_t aIndex) const
Get detected beacon description.
Definition: playerc++.h:650
PlayerCc::AudioProxy::GetChannelCount
uint32_t GetChannelCount() const
Get Channel data count.
Definition: playerc++.h:289
PlayerCc::LaserProxy::MinLeft
double MinLeft() const
Definition: playerc++.h:1178
player_bbox2d
A rectangular bounding box, used to define the size of an object.
Definition: player.h:241
PlayerCc::PtzProxy::GetZoom
double GetZoom() const
Return Zoom.
Definition: playerc++.h:2200
PlayerCc::LocalizeProxy::GetHypoth
player_localize_hypoth_t GetHypoth(uint32_t aIndex) const
Array of possible poses.
Definition: playerc++.h:1347
PlayerCc::LaserProxy::GetMinAngle
double GetMinAngle() const
Scan range for the latest set of data (radians)
Definition: playerc++.h:1063
PlayerCc::Position2dProxy::GetXPos
double GetXPos() const
Set PID terms.
Definition: playerc++.h:1954
playerc_speech_t
Speech proxy data.
Definition: playerc.h:3348
playerc_position1d_t
Position1d device data.
Definition: playerc.h:2587
PlayerCc::IrProxy::GetRange
double GetRange(uint32_t aIndex) const
get the current range
Definition: playerc++.h:998
PlayerCc::ImuProxy::GetPose
player_pose3d_t GetPose() const
get the processed pos of the imu
Definition: playerc++.h:948
PlayerCc::RFIDProxy
The RFIDProxy class is used to control a rfid device.
Definition: playerc++.h:2302
PlayerCc::CameraProxy::GetImageSize
uint32_t GetImageSize() const
Size of the image (bytes)
Definition: playerc++.h:564
PlayerCc::OpaqueProxy::GetCount
uint32_t GetCount() const
How long is the data?
Definition: playerc++.h:1493
PlayerCc::CameraProxy::GetHeight
uint32_t GetHeight() const
Image dimensions (pixels)
Definition: playerc++.h:553
PlayerCc::SpeechRecognitionProxy::GetWord
std::string GetWord(uint32_t aWord) const
Accessor method for getting speech recognition data i.e. words.
Definition: playerc++.h:2469
PlayerCc::Position2dProxy::GetSize
player_bbox3d_t GetSize()
Accessor for the size (fill it in by calling RequestGeom)
Definition: playerc++.h:1892
playerc_gps_t
GPS proxy data.
Definition: playerc.h:1561
PlayerCc::AudioProxy::GetDefaultInputChannel
uint32_t GetDefaultInputChannel() const
Get Default input Channel.
Definition: playerc++.h:268
PlayerCc::Position3dProxy::GetRollSpeed
double GetRollSpeed() const
Accessor method.
Definition: playerc++.h:2110
PlayerCc::Position1dProxy::IsLimitCen
bool IsLimitCen() const
Accessor method.
Definition: playerc++.h:1785
PlayerCc::CameraProxy::GetFormat
uint32_t GetFormat() const
Image format Possible values include.
Definition: playerc++.h:561
PlayerCc::BumperProxy
The BumperProxy class is used to read from a bumper device.
Definition: playerc++.h:470
PlayerCc::LaserProxy::GetConfMaxAngle
double GetConfMaxAngle() const
Scan range from the laser config (call RequestConfigure first) (radians)
Definition: playerc++.h:1074
playerc_audio_t
Audio device data.
Definition: playerc.h:1080
PlayerCc::PlannerProxy::GetWaypoint
player_pose2d_t GetWaypoint(uint32_t aIndex) const
Get the waypoint.
Definition: playerc++.h:1623
boost::mutex::scoped_lock
Definition: playerclient.h:90
playerc_sonar_t
Sonar proxy data.
Definition: playerc.h:3147
playerc_health_t
Note: the structure describing the HEALTH's data packet is declared in Player.
Definition: playerc.h:1824
PlayerCc::LaserProxy::GetMinRight
double GetMinRight() const
Minimum range reading on the right side.
Definition: playerc++.h:1174
PlayerCc::FiducialProxy::GetSensorSize
player_bbox3d_t GetSensorSize() const
The size of the sensor.
Definition: playerc++.h:658
PlayerCc::AudioProxy::GetMixerDetailsCount
uint32_t GetMixerDetailsCount() const
Get Mixer Details Count.
Definition: playerc++.h:262
PlayerCc::LinuxjoystickProxy
The LinuxjoystickProxy class is used to control a joystick device.
Definition: playerc++.h:1251
PlayerCc::Position3dProxy::SetSpeed
void SetSpeed(double aXSpeed, double aYSpeed, double aZSpeed, double aYawSpeed)
Send a motor command for a planar robot.
Definition: playerc++.h:2009
PlayerCc::SonarProxy::GetPoseCount
uint32_t GetPoseCount() const
Number of valid sonar poses.
Definition: playerc++.h:2411
PlayerCc::RangerProxy::GetAngularRes
double GetAngularRes() const
Angular resolution of a scan (configured value)
Definition: playerc++.h:2285
PlayerCc::RangerProxy::GetIntensityCount
uint32_t GetIntensityCount() const
Return the number of intensity readings.
Definition: playerc++.h:2247
PlayerCc::Position3dProxy::GoTo
void GoTo(double aX, double aY, double aZ, double aRoll, double aPitch, double aYaw)
Same as the previous GoTo(), but only takes position arguments, no motion speed setting.
Definition: playerc++.h:2038
PlayerCc::RFIDProxy::GetTagsCount
uint32_t GetTagsCount() const
returns the number of RFID tags
Definition: playerc++.h:2320
PlayerCc::Position3dProxy::GetYSpeed
double GetYSpeed() const
Accessor method.
Definition: playerc++.h:2104
PlayerCc::GripperProxy::GetPose
player_pose3d_t GetPose() const
Get the pose of the gripper.
Definition: playerc++.h:845
PlayerCc::LocalizeProxy::GetMapSizeX
uint32_t GetMapSizeX() const
Map dimensions (cells)
Definition: playerc++.h:1321
PlayerCc::LaserProxy::GetRobotPose
player_pose3d_t GetRobotPose()
Accessor for the pose of the laser's parent object (e.g., a robot).
Definition: playerc++.h:1147
PlayerCc::SpeechRecognitionProxy
The SpeechRecognition proxy provides access to a speech_recognition device.
Definition: playerc++.h:2457
PlayerCc::MapProxy::GetCell
int8_t GetCell(int x, int y) const
Get the (x,y) cell.
Definition: playerc++.h:1444
playerc_blobfinder_t
Blobfinder device data.
Definition: playerc.h:1295
PlayerCc::GpsProxy::GetQuality
uint32_t GetQuality() const
Fix quality.
Definition: playerc++.h:708
playerc_localize_get_particles
PLAYERC_EXPORT int playerc_localize_get_particles(playerc_localize_t *device)
Request the particle set.
PlayerCc::BlobfinderProxy
The BlinkenlightProxy class is used to enable and disable a flashing indicator light, and to set its period, via a blinkenlight device.
Definition: playerc++.h:419
player_pose3d::pyaw
double pyaw
yaw [rad]
Definition: player.h:237
player_bbox3d::sl
double sl
Length [m].
Definition: player.h:255
PlayerCc::CameraProxy::GetDepth
uint32_t GetDepth() const
Image color depth.
Definition: playerc++.h:547
PlayerCc::PowerProxy
The PowerProxy class controls a power device.
Definition: playerc++.h:2123
playerc_graphics2d_t
Graphics2d device data.
Definition: playerc.h:1625
PlayerCc::LinuxjoystickProxy::GetButtons
uint32_t GetButtons() const
return the sensor count
Definition: playerc++.h:1268
PlayerCc::AudioProxy::GetSeqItem
player_audio_seq_item_t GetSeqItem(int aIndex) const
Get Sequence item.
Definition: playerc++.h:286
PlayerCc::IrProxy::GetCount
uint32_t GetCount() const
get the number of IR rangers
Definition: playerc++.h:996
PlayerCc::CameraProxy::GetCompression
uint32_t GetCompression() const
What is the compression type? Currently supported compression types are:
Definition: playerc++.h:581
PlayerCc::Position3dProxy::SetSpeed
void SetSpeed(double aXSpeed, double aYawSpeed)
Same as the previous SetSpeed(), but doesn't take the sideways speed (so use this one for non-holonom...
Definition: playerc++.h:2019
PlayerCc::RFIDProxy::GetRFIDTag
playerc_rfidtag_t GetRFIDTag(uint32_t aIndex) const
returns a RFID tag
Definition: playerc++.h:2322
PlayerCc::Position3dProxy::GetPitch
double GetPitch() const
Accessor method.
Definition: playerc++.h:2095
PlayerCc::RangerProxy::GetRangeCount
uint32_t GetRangeCount() const
Return the number of range readings.
Definition: playerc++.h:2240
PlayerCc::LaserProxy
The LaserProxy class is used to control a laser device.
Definition: playerc++.h:1026
PlayerCc::ActArrayProxy::GetCount
uint32_t GetCount(void) const
Gets the number of actuators in the array.
Definition: playerc++.h:185
PlayerCc::LogProxy
The LogProxy proxy provides access to a log device.
Definition: playerc++.h:1372
PlayerCc::LocalizeProxy
The LocalizeProxy class is used to control a localize device, which can provide multiple pose hypothe...
Definition: playerc++.h:1301
PlayerCc::LogProxy::GetType
int GetType() const
What kind of log device is this? Either PLAYER_LOG_TYPE_READ or PLAYER_LOG_TYPE_WRITE.
Definition: playerc++.h:1391
PlayerCc::PlannerProxy::GetPx
double GetPx() const
Current pose (m)
Definition: playerc++.h:1551
playerc_bumper_t
Bumper proxy data.
Definition: playerc.h:1338
playerc_log_t
Log proxy data.
Definition: playerc.h:2281
PlayerCc::Position3dProxy::GetYawSpeed
double GetYawSpeed() const
Accessor method.
Definition: playerc++.h:2116
PlayerCc::GpsProxy::GetSatellites
uint32_t GetSatellites() const
Number of satellites in view.
Definition: playerc++.h:705
PlayerCc::Position3dProxy::GetRoll
double GetRoll() const
Accessor method.
Definition: playerc++.h:2092
PlayerCc::BlobfinderProxy::GetCount
uint32_t GetCount() const
returns the number of blobs
Definition: playerc++.h:436
PlayerCc::Position2dProxy::GoTo
void GoTo(double aX, double aY, double aYaw)
Same as the previous GoTo(), but only takes position arguments, no motion speed setting.
Definition: playerc++.h:1869
PlayerCc::Graphics3dProxy
The Graphics3dProxy class is used to draw simple graphics into a rendering device provided by Player ...
Definition: playerc++.h:781
PlayerCc::BumperProxy::GetPose
player_bumper_define_t GetPose(uint32_t aIndex) const
Returns a specific bumper pose.
Definition: playerc++.h:502
PlayerCc::Position1dProxy::GetPos
double GetPos() const
Set PID terms.
Definition: playerc++.h:1768
PlayerCc::Position2dProxy::GetYaw
double GetYaw() const
Accessor method.
Definition: playerc++.h:1960
PlayerCc::SpeechRecognitionProxy::mDevice
playerc_speechrecognition_t * mDevice
libplayerc data structure
Definition: playerc++.h:2463
PlayerCc::PtzProxy::GetPan
double GetPan() const
Return Pan (rad)
Definition: playerc++.h:2196
PlayerCc::Position1dProxy::ResetOdometry
void ResetOdometry()
Reset odometry to 0.
Definition: playerc++.h:1755
player_blobfinder_blob
Structure describing a single blob.
Definition: player_interfaces.h:1071
PlayerCc::PlannerProxy::GetGx
double GetGx() const
Goal location (m)
Definition: playerc++.h:1572
PlayerCc::LaserProxy::IntensityOn
bool IntensityOn() const
Whether or not reflectance (i.e., intensity) values are being returned.
Definition: playerc++.h:1077
player_pointcloud3d_element
3D Pointcloud element structure An element as stored in a 3D pointcloud, containing a 3D position plu...
Definition: player_interfaces.h:4798
PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE
#define PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE
Status byte: limit trajectory complete.
Definition: player_interfaces.h:3499
PlayerCc::GripperProxy::GetInnerSize
player_bbox3d_t GetInnerSize() const
Get the inner size of the gripper.
Definition: playerc++.h:849
playerc_position2d_t
Position2d device data.
Definition: playerc.h:2681
playerc_laser_t
Laser proxy data.
Definition: playerc.h:1959
PlayerCc::Pointcloud3dProxy::GetPoint
player_pointcloud3d_element_t GetPoint(uint32_t aIndex) const
return a particular scan value
Definition: playerc++.h:1677
PlayerCc::FiducialProxy::GetCount
uint32_t GetCount() const
The number of beacons detected.
Definition: playerc++.h:647
playerc_joystick_t
joystick proxy data.
Definition: playerc.h:1914
PlayerCc::PlannerProxy::GetCurrentWaypoint
player_pose2d_t GetCurrentWaypoint() const
Get the current waypoint.
Definition: playerc++.h:1602
PlayerCc::Position1dProxy::GetPose
player_pose3d_t GetPose() const
Accessor for the pose (fill it in by calling RequestGeom)
Definition: playerc++.h:1724
playerc_dio_t
Dio proxy data.
Definition: playerc.h:1461
player_pose3d
A pose in space.
Definition: player.h:224
PlayerCc::BumperProxy::GetPoseCount
uint32_t GetPoseCount() const
Returns the number bumper poses.
Definition: playerc++.h:499
PlayerCc::DioProxy::GetDigin
uint32_t GetDigin() const
A bitfield of the current digital inputs.
Definition: playerc++.h:610
PlayerCc::GripperProxy::GetState
uint32_t GetState() const
Get the gripper state.
Definition: playerc++.h:841
playerc_imu_t
IMU proxy state data.
Definition: playerc.h:3559
PlayerCc::GpsProxy::GetHdop
double GetHdop() const
Horizontal dilution of position (HDOP)
Definition: playerc++.h:711
PlayerCc::Position1dProxy::IsLimitMax
bool IsLimitMax() const
Accessor method.
Definition: playerc++.h:1790
PlayerCc::AioProxy::GetCount
uint32_t GetCount() const
Accessor function.
Definition: playerc++.h:223
PlayerCc::SonarProxy::GetScan
double GetScan(uint32_t aIndex) const
return a particular scan value
Definition: playerc++.h:2404
PlayerCc::LaserProxy::GetPose
player_pose3d_t GetPose()
Accessor for the pose of the laser with respect to its parent object (e.g., a robot).
Definition: playerc++.h:1134
player_point_3d
A point in 3D space.
Definition: player.h:190
player_fiducial_item
Info on a single detected fiducial.
Definition: player_interfaces.h:1688
PlayerCc::Position1dProxy
The Position1dProxy class is used to control a position1d device.
Definition: playerc++.h:1691
PlayerCc::MapProxy::GetMap
void GetMap(int8_t *aMap) const
Occupancy for each cell (empty = -1, unknown = 0, occupied = +1)
Definition: playerc++.h:1461
PLAYER_POSITION1D_STATUS_OC
#define PLAYER_POSITION1D_STATUS_OC
Status byte: limit over current.
Definition: player_interfaces.h:3497
player_pose2d::py
double py
Y [m].
Definition: player.h:218
PlayerCc::Position2dProxy::GetYawSpeed
double GetYawSpeed() const
Accessor method.
Definition: playerc++.h:1969
playerc_blackboard
BlackBoard proxy.
Definition: playerc.h:1178
PlayerCc::PlannerProxy::GetPy
double GetPy() const
Current pose (m)
Definition: playerc++.h:1554
PlayerCc::AioProxy
The AioProxy class is used to read from a aio (analog I/O) device.
Definition: playerc++.h:207
PlayerCc::IrProxy
The IrProxy class is used to control an ir device.
Definition: playerc++.h:977
PlayerCc::Position3dProxy::GetStall
bool GetStall() const
Accessor method.
Definition: playerc++.h:2119
PlayerCc::GpsProxy::GetErrHorizontal
double GetErrHorizontal() const
Errors.
Definition: playerc++.h:724
PlayerCc::AudioProxy::GetSeqCount
uint32_t GetSeqCount() const
Get Seq data count.
Definition: playerc++.h:284
PlayerCc::LaserProxy::GetPoint
player_point_2d_t GetPoint(uint32_t aIndex) const
Scan data (Cartesian): x,y (m)
Definition: playerc++.h:1084
PlayerCc::GripperProxy::GetStored
uint32_t GetStored() const
Get the number of currently-stored objects.
Definition: playerc++.h:855
PlayerCc::CameraProxy
The CameraProxy class can be used to get images from a camera device.
Definition: playerc++.h:517
PlayerCc::WSNProxy
The WSNProxy class is used to control a wsn device.
Definition: playerc++.h:2585
player_audio_mixer_channel_detail
Player mixer channel detail.
Definition: player_interfaces.h:1555
PLAYER_POSITION1D_STATUS_ENABLED
#define PLAYER_POSITION1D_STATUS_ENABLED
Status byte: enabled.
Definition: player_interfaces.h:3501
PlayerCc::FiducialProxy
The FiducialProxy class is used to control fiducial devices.
Definition: playerc++.h:631
player_pose3d::proll
double proll
roll [rad]
Definition: player.h:233
PlayerCc::PlannerProxy::GetWy
double GetWy() const
Current waypoint location (m)
Definition: playerc++.h:1596
playerc_wifi_t
Wifi device proxy.
Definition: playerc.h:3229
player_pose3d::pz
double pz
Z [m].
Definition: player.h:231
PlayerCc::Position2dProxy::GetOffset
player_pose3d_t GetOffset()
Accessor for the robot's pose with respect to its.
Definition: playerc++.h:1881
PlayerCc::DioProxy::GetCount
uint32_t GetCount() const
The number of valid digital inputs.
Definition: playerc++.h:607
PlayerCc::SonarProxy::GetCount
uint32_t GetCount() const
return the sensor count
Definition: playerc++.h:2401
PlayerCc::SonarProxy
The SonarProxy class is used to control a sonar device.
Definition: playerc++.h:2384
PlayerCc::PtzProxy::GetTilt
double GetTilt() const
Return Tilt (rad)
Definition: playerc++.h:2198
PlayerCc::GpsProxy::GetAltitude
double GetAltitude() const
Altitude, in meters.
Definition: playerc++.h:702
PlayerCc::AudioProxy::GetWavData
void GetWavData(uint8_t *aData) const
Get Wav data This function copies the wav data into the buffer aImage.
Definition: playerc++.h:276
PlayerCc::LaserProxy::GetID
int GetID() const
get the laser ID, call RequestId first
Definition: playerc++.h:1102
PlayerCc::Graphics2dProxy
The Graphics2dProxy class is used to draw simple graphics into a rendering device provided by Player ...
Definition: playerc++.h:735
player_segment
A line segment, used to construct vector-based maps.
Definition: player.h:287
PlayerCc::LaserProxy::GetRangeRes
double GetRangeRes() const
Range resolution of scan (mm)
Definition: playerc++.h:1057
PlayerCc::SpeechRecognitionProxy::GetCount
uint32_t GetCount(void) const
Gets the number of words.
Definition: playerc++.h:2475
PlayerCc::BlobfinderProxy::GetBlob
playerc_blobfinder_blob_t GetBlob(uint32_t aIndex) const
returns a blob
Definition: playerc++.h:438
PlayerCc::Pointcloud3dProxy::GetCount
uint32_t GetCount() const
return the point count
Definition: playerc++.h:1674
PlayerCc::CameraProxy::GetWidth
uint32_t GetWidth() const
Image dimensions (pixels)
Definition: playerc++.h:550
player_bumper_define
The geometry of a single bumper.
Definition: player_interfaces.h:1929
playerc_limb_t
Limb device data.
Definition: playerc.h:2131
PlayerCc::LocalizeProxy::GetMapScale
double GetMapScale() const
Map scale (m/cell)
Definition: playerc++.h:1329
PlayerCc::DioProxy
The DioProxy class is used to read from a dio (digital I/O) device.
Definition: playerc++.h:590
player_audio_mixer_channel
Player mixer channel.
Definition: player_interfaces.h:1516
PlayerCc::Position3dProxy::GetPitchSpeed
double GetPitchSpeed() const
Accessor method.
Definition: playerc++.h:2113
PlayerCc::PlannerProxy::GetPathDone
uint32_t GetPathDone() const
Have we arrived at the goal?
Definition: playerc++.h:1547
PlayerCc::ActArrayProxy
The ActArrayProxy class is used to control a actarray device.
Definition: playerc++.h:141
player_audio_mixer_channel_list
Player mixer channels.
Definition: player_interfaces.h:1533
player_graphics3d_draw_mode_t
enum player_graphics3d_draw_mode player_graphics3d_draw_mode_t
Drawmode: enumeration that defines the drawing mode.
PlayerCc::MapProxy::GetWidth
uint32_t GetWidth() const
Map size, in cells.
Definition: playerc++.h:1452
PlayerCc::Position1dProxy::GetSize
player_bbox3d_t GetSize() const
Accessor for the size (fill it in by calling RequestGeom)
Definition: playerc++.h:1735
player_localize_hypoth
Hypothesis format.
Definition: player_interfaces.h:2333
PlayerCc::LaserProxy::GetMaxAngle
double GetMaxAngle() const
Scan range for the latest set of data (radians)
Definition: playerc++.h:1065
PLAYER_POSITION1D_STATUS_LIMIT_CEN
#define PLAYER_POSITION1D_STATUS_LIMIT_CEN
Status byte: limit center.
Definition: player_interfaces.h:3493
playerc_actarray_t
Actarray device data.
Definition: playerc.h:986

Last updated 12 September 2005 21:38:45