00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049 #ifndef PLAYERCC_H
00050 #define PLAYERCC_H
00051
00052 #include <cstddef>
00053 #include <cmath>
00054 #include <string>
00055 #include <list>
00056 #include <vector>
00057 #include <cstring>
00058
00059 #include "libplayerc/playerc.h"
00060 #include "libplayerc++/utility.h"
00061 #include "libplayerc++/playerclient.h"
00062 #include "libplayerc++/playererror.h"
00063 #include "libplayerc++/clientproxy.h"
00064 #include "libplayerinterface/interface_util.h"
00065
00066 #if defined (WIN32)
00067 #if defined (PLAYER_STATIC)
00068 #define PLAYERCC_EXPORT
00069 #elif defined (playerc___EXPORTS)
00070 #define PLAYERCC_EXPORT __declspec (dllexport)
00071 #else
00072 #define PLAYERCC_EXPORT __declspec (dllimport)
00073 #endif
00074 #else
00075 #define PLAYERCC_EXPORT
00076 #endif
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092 namespace PlayerCc
00093 {
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00131
00132
00133
00134
00135
00136
00141 class PLAYERCC_EXPORT ActArrayProxy : public ClientProxy
00142 {
00143 private:
00144
00145 void Subscribe(uint32_t aIndex);
00146 void Unsubscribe();
00147
00148
00149 playerc_actarray_t *mDevice;
00150
00151 public:
00152
00154 ActArrayProxy(PlayerClient *aPc, uint32_t aIndex=0);
00156 ~ActArrayProxy();
00157
00160 void RequestGeometry(void);
00161
00163 void SetPowerConfig(bool aVal);
00165 void SetBrakesConfig(bool aVal);
00167 void SetSpeedConfig(uint32_t aJoint, float aSpeed);
00168
00170 void MoveTo(uint32_t aJoint, float aPos);
00172 void MoveToMulti(std::vector<float> aPos);
00174 void MoveAtSpeed(uint32_t aJoint, float aSpeed);
00176 void MoveAtSpeedMulti(std::vector<float> aSpeed);
00178 void MoveHome(int aJoint);
00180 void SetActuatorCurrent(uint32_t aJoint, float aCurrent);
00182 void SetActuatorCurrentMulti(std::vector<float> aCurrent);
00183
00185 uint32_t GetCount(void) const { return GetVar(mDevice->actuators_count); }
00187 player_actarray_actuator_t GetActuatorData(uint32_t aJoint) const;
00189 player_actarray_actuatorgeom_t GetActuatorGeom(uint32_t aJoint) const;
00191 player_point_3d_t GetBasePos(void) const { return GetVar(mDevice->base_pos); }
00193 player_orientation_3d_t GetBaseOrientation(void) const { return GetVar(mDevice->base_orientation); }
00194
00195
00200 player_actarray_actuator_t operator [](uint32_t aJoint)
00201 { return(GetActuatorData(aJoint)); }
00202 };
00203
00207 class PLAYERCC_EXPORT AioProxy : public ClientProxy
00208 {
00209 private:
00210
00211 void Subscribe(uint32_t aIndex);
00212 void Unsubscribe();
00213
00214
00215 playerc_aio_t *mDevice;
00216
00217 public:
00218
00219 AioProxy (PlayerClient *aPc, uint32_t aIndex=0);
00220 ~AioProxy();
00221
00223 uint32_t GetCount() const { return(GetVar(mDevice->voltages_count)); };
00224
00226 double GetVoltage(uint32_t aIndex) const
00227 { return(GetVar(mDevice->voltages[aIndex])); };
00228
00230 void SetVoltage(uint32_t aIndex, double aVoltage);
00231
00236 double operator [](uint32_t aIndex) const
00237 { return GetVoltage(aIndex); }
00238
00239 };
00240
00241
00245 class PLAYERCC_EXPORT AudioProxy : public ClientProxy
00246 {
00247
00248 private:
00249
00250 void Subscribe(uint32_t aIndex);
00251 void Unsubscribe();
00252
00253
00254 playerc_audio_t *mDevice;
00255
00256 public:
00257
00258 AudioProxy(PlayerClient *aPc, uint32_t aIndex=0);
00259 ~AudioProxy();
00260
00262 uint32_t GetMixerDetailsCount() const {return(GetVar(mDevice->channel_details_list.details_count));};
00264 player_audio_mixer_channel_detail_t GetMixerDetails(int aIndex) const {return(GetVar(mDevice->channel_details_list.details[aIndex]));};
00266 uint32_t GetDefaultOutputChannel() const {return(GetVar(mDevice->channel_details_list.default_output));};
00268 uint32_t GetDefaultInputChannel() const {return(GetVar(mDevice->channel_details_list.default_input));};
00269
00271 uint32_t GetWavDataLength() const {return(GetVar(mDevice->wav_data.data_count));};
00276 void GetWavData(uint8_t* aData) const
00277 {
00278 return GetVarByRef(mDevice->wav_data.data,
00279 mDevice->wav_data.data+GetWavDataLength(),
00280 aData);
00281 };
00282
00284 uint32_t GetSeqCount() const {return(GetVar(mDevice->seq_data.tones_count));};
00286 player_audio_seq_item_t GetSeqItem(int aIndex) const {return(GetVar(mDevice->seq_data.tones[aIndex]));};
00287
00289 uint32_t GetChannelCount() const {return(GetVar(mDevice->mixer_data.channels_count));};
00291 player_audio_mixer_channel_t GetChannel(int aIndex) const {return(GetVar(mDevice->mixer_data.channels[aIndex]));};
00293 uint32_t GetState(void) const {return(GetVar(mDevice->state));};
00294
00295
00296
00298 void PlayWav(uint32_t aDataCount, uint8_t *aData, uint32_t aFormat);
00299
00301 void SetWavStremRec(bool aState);
00302
00304 void PlaySample(int aIndex);
00305
00307 void PlaySeq(player_audio_seq_t * aTones);
00308
00310 void SetMultMixerLevels(player_audio_mixer_channel_list_t * aLevels);
00311
00313 void SetMixerLevel(uint32_t index, float amplitude, uint8_t active);
00314
00317 void RecordWav();
00318
00320 void LoadSample(int aIndex, uint32_t aDataCount, uint8_t *aData, uint32_t aFormat);
00321
00324 void GetSample(int aIndex);
00325
00327 void RecordSample(int aIndex, uint32_t aLength);
00328
00331 void GetMixerLevels();
00332
00335 void GetMixerDetails();
00336
00337 };
00338
00346 class PLAYERCC_EXPORT BlackBoardProxy : public ClientProxy
00347 {
00348 private:
00349 void Subscribe(uint32_t aIndex);
00350 void Unsubscribe();
00351
00352
00353 playerc_blackboard_t *mDevice;
00354
00355 public:
00357 BlackBoardProxy(PlayerClient *aPc, uint32_t aIndex=0);
00359 ~BlackBoardProxy();
00361 player_blackboard_entry_t *SubscribeToKey(const char *key, const char* group = "");
00363 void UnsubscribeFromKey(const char *key, const char* group = "");
00365 void SubscribeToGroup(const char* key);
00367 void UnsubscribeFromGroup(const char* group);
00369 void SetEntry(const player_blackboard_entry_t &entry);
00371 player_blackboard_entry_t *GetEntry(const char* key, const char* group);
00373 void SetEventHandler(void (*on_blackboard_event)(playerc_blackboard_t *, player_blackboard_entry_t));
00374 };
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00419 class PLAYERCC_EXPORT BlobfinderProxy : public ClientProxy
00420 {
00421 private:
00422
00423 void Subscribe(uint32_t aIndex);
00424 void Unsubscribe();
00425
00426
00427 playerc_blobfinder_t *mDevice;
00428
00429 public:
00431 BlobfinderProxy(PlayerClient *aPc, uint32_t aIndex=0);
00433 ~BlobfinderProxy();
00434
00436 uint32_t GetCount() const { return GetVar(mDevice->blobs_count); };
00438 playerc_blobfinder_blob_t GetBlob(uint32_t aIndex) const
00439 { return GetVar(mDevice->blobs[aIndex]);};
00440
00442 uint32_t GetWidth() const { return GetVar(mDevice->width); };
00444 uint32_t GetHeight() const { return GetVar(mDevice->height); };
00445
00450 playerc_blobfinder_blob_t operator [](uint32_t aIndex) const
00451 { return(GetBlob(aIndex)); }
00452
00453
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464 };
00465
00470 class PLAYERCC_EXPORT BumperProxy : public ClientProxy
00471 {
00472
00473 private:
00474
00475 void Subscribe(uint32_t aIndex);
00476 void Unsubscribe();
00477
00478
00479 playerc_bumper_t *mDevice;
00480
00481 public:
00482
00483 BumperProxy(PlayerClient *aPc, uint32_t aIndex=0);
00484 ~BumperProxy();
00485
00486 uint32_t GetCount() const { return GetVar(mDevice->bumper_count); };
00487
00489 uint32_t IsBumped(uint32_t aIndex) const
00490 { return GetVar(mDevice->bumpers[aIndex]); };
00491
00493 bool IsAnyBumped();
00494
00496 void RequestBumperConfig();
00497
00499 uint32_t GetPoseCount() const { return GetVar(mDevice->pose_count); };
00500
00502 player_bumper_define_t GetPose(uint32_t aIndex) const
00503 { return GetVar(mDevice->poses[aIndex]); };
00504
00509 bool operator [](uint32_t aIndex) const
00510 { return IsBumped(aIndex) != 0 ? true : false; }
00511
00512 };
00513
00517 class PLAYERCC_EXPORT CameraProxy : public ClientProxy
00518 {
00519
00520 private:
00521
00522 virtual void Subscribe(uint32_t aIndex);
00523 virtual void Unsubscribe();
00524
00525
00526 playerc_camera_t *mDevice;
00527
00528 std::string mPrefix;
00529 int mFrameNo;
00530
00531 public:
00532
00534 CameraProxy (PlayerClient *aPc, uint32_t aIndex=0);
00535
00536 virtual ~CameraProxy();
00537
00541 void SaveFrame(const std::string aPrefix, uint32_t aWidth=4);
00542
00544 void Decompress();
00545
00547 uint32_t GetDepth() const { return GetVar(mDevice->bpp); };
00548
00550 uint32_t GetWidth() const { return GetVar(mDevice->width); };
00551
00553 uint32_t GetHeight() const { return GetVar(mDevice->height); };
00554
00561 uint32_t GetFormat() const { return GetVar(mDevice->format); };
00562
00564 uint32_t GetImageSize() const { return GetVar(mDevice->image_count); };
00565
00570 void GetImage(uint8_t* aImage) const
00571 {
00572 return GetVarByRef(mDevice->image,
00573 mDevice->image+GetVar(mDevice->image_count),
00574 aImage);
00575 };
00576
00581 uint32_t GetCompression() const { return GetVar(mDevice->compression); };
00582
00583 };
00584
00585
00590 class PLAYERCC_EXPORT DioProxy : public ClientProxy
00591 {
00592 private:
00593
00594 void Subscribe(uint32_t aIndex);
00595 void Unsubscribe();
00596
00597
00598 playerc_dio_t *mDevice;
00599
00600 public:
00602 DioProxy(PlayerClient *aPc, uint32_t aIndex=0);
00604 ~DioProxy();
00605
00607 uint32_t GetCount() const { return GetVar(mDevice->count); };
00608
00610 uint32_t GetDigin() const { return GetVar(mDevice->digin); };
00611
00613 bool GetInput(uint32_t aIndex) const;
00614
00616 void SetOutput(uint32_t aCount, uint32_t aDigout);
00617
00622 uint32_t operator [](uint32_t aIndex) const
00623 { return GetInput(aIndex); }
00624 };
00625
00631 class PLAYERCC_EXPORT FiducialProxy : public ClientProxy
00632 {
00633 private:
00634 void Subscribe(uint32_t aIndex);
00635 void Unsubscribe();
00636
00637
00638 playerc_fiducial_t *mDevice;
00639
00640 public:
00642 FiducialProxy(PlayerClient *aPc, uint32_t aIndex=0);
00644 ~FiducialProxy();
00645
00647 uint32_t GetCount() const { return GetVar(mDevice->fiducials_count); };
00648
00650 player_fiducial_item_t GetFiducialItem(uint32_t aIndex) const
00651 { return GetVar(mDevice->fiducials[aIndex]);};
00652
00654 player_pose3d_t GetSensorPose() const
00655 { return GetVar(mDevice->fiducial_geom.pose);};
00656
00658 player_bbox3d_t GetSensorSize() const
00659 { return GetVar(mDevice->fiducial_geom.size);};
00660
00662 player_bbox2d_t GetFiducialSize() const
00663 { return GetVar(mDevice->fiducial_geom.fiducial_size);};
00664
00666 void RequestGeometry();
00667
00672 player_fiducial_item_t operator [](uint32_t aIndex) const
00673 { return GetFiducialItem(aIndex); }
00674 };
00675
00679 class PLAYERCC_EXPORT GpsProxy : public ClientProxy
00680 {
00681
00682 private:
00683
00684 void Subscribe(uint32_t aIndex);
00685 void Unsubscribe();
00686
00687
00688 playerc_gps_t *mDevice;
00689
00690 public:
00691
00692
00693 GpsProxy(PlayerClient *aPc, uint32_t aIndex=0);
00694
00695 ~GpsProxy();
00696
00698 double GetLatitude() const { return GetVar(mDevice->lat); };
00699 double GetLongitude() const { return GetVar(mDevice->lon); };
00700
00702 double GetAltitude() const { return GetVar(mDevice->alt); };
00703
00705 uint32_t GetSatellites() const { return GetVar(mDevice->sat_count); };
00706
00708 uint32_t GetQuality() const { return GetVar(mDevice->quality); };
00709
00711 double GetHdop() const { return GetVar(mDevice->hdop); };
00712
00714 double GetVdop() const { return GetVar(mDevice->vdop); };
00715
00717 double GetUtmEasting() const { return GetVar(mDevice->utm_e); };
00718 double GetUtmNorthing() const { return GetVar(mDevice->utm_n); };
00719
00721 double GetTime() const { return GetVar(mDevice->utc_time); };
00722
00724 double GetErrHorizontal() const { return GetVar(mDevice->err_horz); };
00725 double GetErrVertical() const { return GetVar(mDevice->err_vert); };
00726 };
00727
00735 class PLAYERCC_EXPORT Graphics2dProxy : public ClientProxy
00736 {
00737
00738 private:
00739
00740
00741 void Subscribe(uint32_t aIndex);
00742
00743 void Unsubscribe();
00744
00745
00746 playerc_graphics2d_t *mDevice;
00747
00748 public:
00749
00750 Graphics2dProxy(PlayerClient *aPc, uint32_t aIndex=0);
00751
00752 ~Graphics2dProxy();
00753
00755 void Color(player_color_t col);
00756
00758 void Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
00759
00761 void Clear(void);
00762
00764 void DrawPoints(player_point_2d_t pts[], int count);
00765
00767 void DrawPolygon(player_point_2d_t pts[],
00768 int count,
00769 bool filled,
00770 player_color_t fill_color);
00771
00773 void DrawPolyline(player_point_2d_t pts[], int count);
00774 };
00775
00781 class PLAYERCC_EXPORT Graphics3dProxy : public ClientProxy
00782 {
00783
00784 private:
00785
00786
00787 void Subscribe(uint32_t aIndex);
00788
00789 void Unsubscribe();
00790
00791
00792 playerc_graphics3d_t *mDevice;
00793
00794 public:
00795
00796 Graphics3dProxy(PlayerClient *aPc, uint32_t aIndex=0);
00797
00798 ~Graphics3dProxy();
00799
00801 void Color(player_color_t col);
00802
00804 void Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
00805
00807 void Clear(void);
00808
00810 void Draw(player_graphics3d_draw_mode_t mode, player_point_3d_t pts[], int count);
00811
00812 };
00813
00818 class PLAYERCC_EXPORT GripperProxy : public ClientProxy
00819 {
00820
00821 private:
00822
00823 void Subscribe(uint32_t aIndex);
00824 void Unsubscribe();
00825
00826
00827 playerc_gripper_t *mDevice;
00828
00829 public:
00830
00832 GripperProxy(PlayerClient *aPc, uint32_t aIndex=0);
00834 ~GripperProxy();
00835
00838 void RequestGeometry(void);
00839
00841 uint32_t GetState() const { return GetVar(mDevice->state); };
00843 uint32_t GetBeams() const { return GetVar(mDevice->beams); };
00845 player_pose3d_t GetPose() const { return GetVar(mDevice->pose); };
00847 player_bbox3d_t GetOuterSize() const { return GetVar(mDevice->outer_size); };
00849 player_bbox3d_t GetInnerSize() const { return GetVar(mDevice->inner_size); };
00851 uint32_t GetNumBeams() const { return GetVar(mDevice->num_beams); };
00853 uint32_t GetCapacity() const { return GetVar(mDevice->capacity); };
00855 uint32_t GetStored() const { return GetVar(mDevice->stored); };
00856
00858 void Open();
00860 void Close();
00862 void Stop();
00864 void Store();
00866 void Retrieve();
00867 };
00868
00871 class PLAYERCC_EXPORT HealthProxy : public ClientProxy
00872 {
00873
00874 private:
00875
00876 void Subscribe(uint32_t aIndex);
00877 void Unsubscribe();
00878
00879
00880 playerc_health_t *mDevice;
00881
00882 public:
00884 HealthProxy(PlayerClient *aPc, uint32_t aIndex=0);
00886 ~HealthProxy();
00887
00889 float GetIdleCPU();
00890
00892 float GetSystemCPU();
00893
00895 float GetUserCPU();
00896
00898 int64_t GetMemTotal();
00899
00901 int64_t GetMemUsed();
00902
00904 int64_t GetMemFree();
00905
00907 int64_t GetSwapTotal();
00908
00910 int64_t GetSwapUsed();
00911
00913 int64_t GetSwapFree();
00914
00916 float GetPercMemUsed();
00917
00919 float GetPercSwapUsed();
00920
00922 float GetPercTotalUsed();
00923 };
00924
00925
00926
00931 class PLAYERCC_EXPORT ImuProxy : public ClientProxy
00932 {
00933 private:
00934 void Subscribe(uint32_t aIndex);
00935 void Unsubscribe();
00936
00937
00938 playerc_imu_t *mDevice;
00939
00940 public:
00941
00943 ImuProxy(PlayerClient *aPc, uint32_t aIndex=0);
00945 ~ImuProxy();
00946
00948 player_pose3d_t GetPose() const { return GetVar(mDevice->pose); };
00950 float GetXAccel();
00951 float GetYAccel();
00952 float GetZAccel();
00953 float GetXGyro();
00954 float GetYGyro();
00955 float GetZGyro();
00956 float GetXMagn();
00957 float GetYMagn();
00958 float GetZMagn();
00959
00960 player_imu_data_calib_t GetRawValues() const
00961 { return GetVar(mDevice->calib_data); };
00962
00964 void SetDatatype(int aDatatype);
00965
00967 void ResetOrientation(int aValue);
00968
00969
00970 };
00971
00972
00977 class PLAYERCC_EXPORT IrProxy : public ClientProxy
00978 {
00979
00980 private:
00981
00982 void Subscribe(uint32_t aIndex);
00983 void Unsubscribe();
00984
00985
00986 playerc_ir_t *mDevice;
00987
00988 public:
00989
00991 IrProxy(PlayerClient *aPc, uint32_t aIndex=0);
00993 ~IrProxy();
00994
00996 uint32_t GetCount() const { return GetVar(mDevice->data.ranges_count); };
00998 double GetRange(uint32_t aIndex) const
00999 { return GetVar(mDevice->data.ranges[aIndex]); };
01001 double GetVoltage(uint32_t aIndex) const
01002 { return GetVar(mDevice->data.voltages[aIndex]); };
01004 uint32_t GetPoseCount() const { return GetVar(mDevice->poses.poses_count); };
01006 player_pose3d_t GetPose(uint32_t aIndex) const
01007 {return GetVar(mDevice->poses.poses[aIndex]);};
01008
01010 void RequestGeom();
01011
01016 double operator [](uint32_t aIndex) const
01017 { return GetRange(aIndex); }
01018
01019 };
01020
01026 class PLAYERCC_EXPORT LaserProxy : public ClientProxy
01027 {
01028 private:
01029
01030 void Subscribe(uint32_t aIndex);
01031 void Unsubscribe();
01032
01033
01034 playerc_laser_t *mDevice;
01035
01036
01037 double min_angle, max_angle, scan_res, range_res, scanning_frequency;
01038 bool intensity;
01039
01040 public:
01041
01043 LaserProxy(PlayerClient *aPc, uint32_t aIndex=0);
01045 ~LaserProxy();
01046
01048 uint32_t GetCount() const { return GetVar(mDevice->scan_count); };
01049
01051 double GetMaxRange() const { return GetVar(mDevice->max_range); };
01052
01054 double GetScanRes() const { return GetVar(mDevice->scan_res); };
01055
01057 double GetRangeRes() const { return GetVar(mDevice->range_res); };
01058
01060 double GetScanningFrequency() const { return GetVar(mDevice->scanning_frequency); };
01061
01063 double GetMinAngle() const { return GetVar(mDevice->scan_start); };
01065 double GetMaxAngle() const
01066 {
01067 scoped_lock_t lock(mPc->mMutex);
01068 return mDevice->scan_start + (mDevice->scan_count - 1)*mDevice->scan_res;
01069 };
01070
01072 double GetConfMinAngle() const { return min_angle; };
01074 double GetConfMaxAngle() const { return max_angle; };
01075
01077 bool IntensityOn() const { return GetVar(mDevice->intensity_on) != 0 ? true : false; };
01078
01079
01080
01081
01082
01084 player_point_2d_t GetPoint(uint32_t aIndex) const
01085 { return GetVar(mDevice->point[aIndex]); };
01086
01087
01089 double GetRange(uint32_t aIndex) const
01090 { return GetVar(mDevice->ranges[aIndex]); };
01091
01093 double GetBearing(uint32_t aIndex) const
01094 { return GetVar(mDevice->scan[aIndex][1]); };
01095
01096
01098 int GetIntensity(uint32_t aIndex) const
01099 { return GetVar(mDevice->intensity[aIndex]); };
01100
01102 int GetID() const
01103 { return GetVar(mDevice->laser_id); };
01104
01105
01114 void Configure(double aMinAngle,
01115 double aMaxAngle,
01116 uint32_t aScanRes,
01117 uint32_t aRangeRes,
01118 bool aIntensity,
01119 double aScanningFrequency);
01120
01123 void RequestConfigure();
01124
01126 void RequestID();
01127
01130 void RequestGeom();
01131
01134 player_pose3d_t GetPose()
01135 {
01136 player_pose3d_t p;
01137 scoped_lock_t lock(mPc->mMutex);
01138
01139 p.px = mDevice->pose[0];
01140 p.py = mDevice->pose[1];
01141 p.pyaw = mDevice->pose[2];
01142 return(p);
01143 }
01144
01147 player_pose3d_t GetRobotPose()
01148 {
01149 player_pose3d_t p;
01150 scoped_lock_t lock(mPc->mMutex);
01151
01152 p.px = mDevice->robot_pose[0];
01153 p.py = mDevice->robot_pose[1];
01154 p.pyaw = mDevice->robot_pose[2];
01155 return(p);
01156 }
01157
01159 player_bbox3d_t GetSize()
01160 {
01161 player_bbox3d_t b;
01162 scoped_lock_t lock(mPc->mMutex);
01163
01164 b.sl = mDevice->size[0];
01165 b.sw = mDevice->size[1];
01166 return(b);
01167 }
01168
01170 double GetMinLeft() const
01171 { return GetVar(mDevice->min_left); };
01172
01174 double GetMinRight() const
01175 { return GetVar(mDevice->min_right); };
01176
01178 double MinLeft () const
01179 { return GetMinLeft(); }
01180
01182 double MinRight () const
01183 { return GetMinRight(); }
01184
01189 double operator [] (uint32_t index) const
01190 { return GetRange(index);}
01191
01192 };
01193
01194
01199 class PLAYERCC_EXPORT LimbProxy : public ClientProxy
01200 {
01201 private:
01202
01203 void Subscribe(uint32_t aIndex);
01204 void Unsubscribe();
01205
01206
01207 playerc_limb_t *mDevice;
01208
01209 public:
01210
01211 LimbProxy(PlayerClient *aPc, uint32_t aIndex=0);
01212 ~LimbProxy();
01213
01216 void RequestGeometry(void);
01217
01219 void SetPowerConfig(bool aVal);
01221 void SetBrakesConfig(bool aVal);
01223 void SetSpeedConfig(float aSpeed);
01224
01226 void MoveHome(void);
01228 void Stop(void);
01230 void SetPose(float aPX, float aPY, float aPZ,
01231 float aAX, float aAY, float aAZ,
01232 float aOX, float aOY, float aOZ);
01234 void SetPosition(float aX, float aY, float aZ);
01237 void VectorMove(float aX, float aY, float aZ, float aLength);
01238
01240 player_limb_data_t GetData(void) const;
01242 player_limb_geom_req_t GetGeom(void) const;
01243 };
01244
01245
01251 class PLAYERCC_EXPORT LinuxjoystickProxy : public ClientProxy
01252 {
01253 private:
01254
01255 void Subscribe(uint32_t aIndex);
01256 void Unsubscribe();
01257
01258
01259 playerc_joystick_t *mDevice;
01260
01261 public:
01263 LinuxjoystickProxy(PlayerClient *aPc, uint32_t aIndex=0);
01265 ~LinuxjoystickProxy();
01266
01268 uint32_t GetButtons() const { return GetVar(mDevice->buttons); };
01269
01271 double GetAxes(uint32_t aIndex) const
01272 { if (GetVar(mDevice->axes_count) <= (int32_t)aIndex) return -1.0; return GetVar(mDevice->pos[aIndex]); };
01275 double operator [] (uint32_t aIndex) const { return GetAxes(aIndex); }
01276
01278 uint32_t GetAxesCount() const { return GetVar(mDevice->axes_count); };
01279
01281
01282
01283
01284
01285
01286
01287
01288
01289
01290
01292
01293 };
01294
01295
01301 class PLAYERCC_EXPORT LocalizeProxy : public ClientProxy
01302 {
01303
01304 private:
01305
01306 void Subscribe(uint32_t aIndex);
01307 void Unsubscribe();
01308
01309
01310 playerc_localize_t *mDevice;
01311
01312 public:
01313
01315 LocalizeProxy(PlayerClient *aPc, uint32_t aIndex=0);
01317 ~LocalizeProxy();
01318
01320
01321 uint32_t GetMapSizeX() const { return GetVar(mDevice->map_size_x); };
01322 uint32_t GetMapSizeY() const { return GetVar(mDevice->map_size_y); };
01323
01324
01325 uint32_t GetMapTileX() const { return GetVar(mDevice->map_tile_x); };
01326 uint32_t GetMapTileY() const { return GetVar(mDevice->map_tile_y); };
01327
01329 double GetMapScale() const { return GetVar(mDevice->map_scale); };
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01341 uint32_t GetPendingCount() const { return GetVar(mDevice->pending_count); };
01342
01344 uint32_t GetHypothCount() const { return GetVar(mDevice->hypoth_count); };
01345
01347 player_localize_hypoth_t GetHypoth(uint32_t aIndex) const
01348 { return GetVar(mDevice->hypoths[aIndex]); };
01349
01351 int GetParticles()
01352 { return playerc_localize_get_particles(mDevice); }
01353
01355 player_pose2d_t GetParticlePose(int index) const;
01356
01358 void SetPose(double pose[3], double cov[3]);
01359
01361 uint32_t GetNumHypoths() const { return GetVar(mDevice->hypoth_count); };
01362
01365 uint32_t GetNumParticles() const { return GetVar(mDevice->num_particles); };
01366 };
01367
01368
01372 class PLAYERCC_EXPORT LogProxy : public ClientProxy
01373 {
01374 private:
01375
01376 void Subscribe(uint32_t aIndex);
01377 void Unsubscribe();
01378
01379
01380 playerc_log_t *mDevice;
01381
01382 public:
01384 LogProxy(PlayerClient *aPc, uint32_t aIndex=0);
01385
01387 ~LogProxy();
01388
01391 int GetType() const { return GetVar(mDevice->type); };
01392
01394 int GetState() const { return GetVar(mDevice->state); };
01395
01397 void QueryState();
01398
01401 void SetState(int aState);
01402
01404 void SetWriteState(int aState);
01405
01407 void SetReadState(int aState);
01408
01410 void Rewind();
01411
01413 void SetFilename(const std::string aFilename);
01414 };
01415
01419 class PLAYERCC_EXPORT MapProxy : public ClientProxy
01420 {
01421 private:
01422
01423 void Subscribe(uint32_t aIndex);
01424 void Unsubscribe();
01425
01426
01427 playerc_map_t *mDevice;
01428
01429 public:
01431 MapProxy(PlayerClient *aPc, uint32_t aIndex=0);
01432
01434 ~MapProxy();
01435
01437 void RequestMap();
01438
01440 int GetCellIndex(int x, int y) const
01441 { return y*GetWidth() + x; };
01442
01444 int8_t GetCell(int x, int y) const
01445 { return GetVar(mDevice->cells[GetCellIndex(x,y)]); };
01446
01448 double GetResolution() const { return GetVar(mDevice->resolution); };
01449
01452 uint32_t GetWidth() const { return GetVar(mDevice->width); };
01455 uint32_t GetHeight() const { return GetVar(mDevice->height); };
01456
01457 double GetOriginX() const { return GetVar(mDevice->origin[0]); };
01458 double GetOriginY() const { return GetVar(mDevice->origin[1]); };
01459
01461 void GetMap(int8_t* aMap) const
01462 {
01463 return GetVarByRef(reinterpret_cast<int8_t*>(mDevice->cells),
01464 reinterpret_cast<int8_t*>(mDevice->cells+GetWidth()*GetHeight()),
01465 aMap);
01466 };
01467 };
01468
01474 class PLAYERCC_EXPORT OpaqueProxy : public ClientProxy
01475 {
01476
01477 private:
01478
01479 void Subscribe(uint32_t aIndex);
01480 void Unsubscribe();
01481
01482
01483 playerc_opaque_t *mDevice;
01484
01485 public:
01486
01488 OpaqueProxy(PlayerClient *aPc, uint32_t aIndex=0);
01490 ~OpaqueProxy();
01491
01493 uint32_t GetCount() const { return GetVar(mDevice->data_count); };
01494
01496 void GetData(uint8_t* aDest) const
01497 {
01498 return GetVarByRef(mDevice->data,
01499 mDevice->data+GetVar(mDevice->data_count),
01500 aDest);
01501 };
01502
01504 void SendCmd(player_opaque_data_t* aData);
01505
01507 int SendReq(player_opaque_data_t* aRequest);
01508
01509 };
01510
01514 class PLAYERCC_EXPORT PlannerProxy : public ClientProxy
01515 {
01516
01517 private:
01518
01519 void Subscribe(uint32_t aIndex);
01520 void Unsubscribe();
01521
01522
01523 playerc_planner_t *mDevice;
01524
01525 public:
01526
01528 PlannerProxy(PlayerClient *aPc, uint32_t aIndex=0);
01530 ~PlannerProxy();
01531
01533 void SetGoalPose(double aGx, double aGy, double aGa);
01534
01537 void RequestWaypoints();
01538
01541 void SetEnable(bool aEnable);
01542
01544 uint32_t GetPathValid() const { return GetVar(mDevice->path_valid); };
01545
01547 uint32_t GetPathDone() const { return GetVar(mDevice->path_done); };
01548
01551 double GetPx() const { return GetVar(mDevice->px); };
01554 double GetPy() const { return GetVar(mDevice->py); };
01557 double GetPa() const { return GetVar(mDevice->pa); };
01558
01560 player_pose2d_t GetPose() const
01561 {
01562 player_pose2d_t p;
01563 scoped_lock_t lock(mPc->mMutex);
01564 p.px = mDevice->px;
01565 p.py = mDevice->py;
01566 p.pa = mDevice->pa;
01567 return(p);
01568 }
01569
01572 double GetGx() const { return GetVar(mDevice->gx); };
01575 double GetGy() const { return GetVar(mDevice->gy); };
01578 double GetGa() const { return GetVar(mDevice->ga); };
01579
01581 player_pose2d_t GetGoal() const
01582 {
01583 player_pose2d_t p;
01584 scoped_lock_t lock(mPc->mMutex);
01585 p.px = mDevice->gx;
01586 p.py = mDevice->gy;
01587 p.pa = mDevice->ga;
01588 return(p);
01589 }
01590
01593 double GetWx() const { return GetVar(mDevice->wx); };
01596 double GetWy() const { return GetVar(mDevice->wy); };
01599 double GetWa() const { return GetVar(mDevice->wa); };
01600
01602 player_pose2d_t GetCurrentWaypoint() const
01603 {
01604 player_pose2d_t p;
01605 scoped_lock_t lock(mPc->mMutex);
01606 p.px = mDevice->wx;
01607 p.py = mDevice->wy;
01608 p.pa = mDevice->wa;
01609 return(p);
01610 }
01611
01614 double GetIx(int i) const;
01617 double GetIy(int i) const;
01620 double GetIa(int i) const;
01621
01623 player_pose2d_t GetWaypoint(uint32_t aIndex) const
01624 {
01625 assert(aIndex < GetWaypointCount());
01626 player_pose2d_t p;
01627 scoped_lock_t lock(mPc->mMutex);
01628 p.px = mDevice->waypoints[aIndex][0];
01629 p.py = mDevice->waypoints[aIndex][1];
01630 p.pa = mDevice->waypoints[aIndex][2];
01631 return(p);
01632 }
01633
01637 int GetCurrentWaypointId() const
01638 { return GetVar(mDevice->curr_waypoint); };
01639
01641 uint32_t GetWaypointCount() const
01642 { return GetVar(mDevice->waypoint_count); };
01643
01648 player_pose2d_t operator [](uint32_t aIndex) const
01649 { return GetWaypoint(aIndex); }
01650
01651 };
01652
01656 class PLAYERCC_EXPORT Pointcloud3dProxy : public ClientProxy
01657 {
01658 private:
01659
01660 void Subscribe(uint32_t aIndex);
01661 void Unsubscribe();
01662
01663
01664 playerc_pointcloud3d_t *mDevice;
01665
01666 public:
01668 Pointcloud3dProxy(PlayerClient *aPc, uint32_t aIndex=0);
01669
01671 ~Pointcloud3dProxy();
01672
01674 uint32_t GetCount() const { return GetVar(mDevice->points_count); };
01675
01677 player_pointcloud3d_element_t GetPoint(uint32_t aIndex) const
01678 { return GetVar(mDevice->points[aIndex]); };
01679
01682 player_pointcloud3d_element_t operator [] (uint32_t aIndex) const { return GetPoint(aIndex); }
01683
01684 };
01685
01686
01691 class PLAYERCC_EXPORT Position1dProxy : public ClientProxy
01692 {
01693
01694 private:
01695
01696 void Subscribe(uint32_t aIndex);
01697 void Unsubscribe();
01698
01699
01700 playerc_position1d_t *mDevice;
01701
01702 public:
01703
01705 Position1dProxy(PlayerClient *aPc, uint32_t aIndex=0);
01707 ~Position1dProxy();
01708
01712 void SetSpeed(double aVel);
01713
01717 void GoTo(double aPos, double aVel);
01718
01721 void RequestGeom();
01722
01724 player_pose3d_t GetPose() const
01725 {
01726 player_pose3d_t p;
01727 scoped_lock_t lock(mPc->mMutex);
01728 p.px = mDevice->pose[0];
01729 p.py = mDevice->pose[1];
01730 p.pyaw = mDevice->pose[2];
01731 return(p);
01732 }
01733
01735 player_bbox3d_t GetSize() const
01736 {
01737 player_bbox3d_t b;
01738 scoped_lock_t lock(mPc->mMutex);
01739 b.sl = mDevice->size[0];
01740 b.sw = mDevice->size[1];
01741 return(b);
01742 }
01743
01748 void SetMotorEnable(bool enable);
01749
01752 void SetOdometry(double aPos);
01753
01755 void ResetOdometry() { SetOdometry(0); };
01756
01758
01759
01761
01762
01765
01766
01768 double GetPos() const { return GetVar(mDevice->pos); };
01769
01771 double GetVel() const { return GetVar(mDevice->vel); };
01772
01774 bool GetStall() const { return GetVar(mDevice->stall) != 0 ? true : false; };
01775
01777 uint8_t GetStatus() const { return GetVar(mDevice->status); };
01778
01780 bool IsLimitMin() const
01781 { return (GetVar(mDevice->status) &
01782 (1 << PLAYER_POSITION1D_STATUS_LIMIT_MIN)) > 0; };
01783
01785 bool IsLimitCen() const
01786 { return (GetVar(mDevice->status) &
01787 (1 << PLAYER_POSITION1D_STATUS_LIMIT_CEN)) > 0; };
01788
01790 bool IsLimitMax() const
01791 { return (GetVar(mDevice->status) &
01792 (1 << PLAYER_POSITION1D_STATUS_LIMIT_MAX)) > 0; };
01793
01795 bool IsOverCurrent() const
01796 { return (GetVar(mDevice->status) &
01797 (1 << PLAYER_POSITION1D_STATUS_OC)) > 0; };
01798
01800 bool IsTrajComplete() const
01801 { return (GetVar(mDevice->status) &
01802 (1 << PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE)) > 0; };
01803
01805 bool IsEnabled() const
01806 { return (GetVar(mDevice->status) &
01807 (1 << PLAYER_POSITION1D_STATUS_ENABLED)) > 0; };
01808
01809 };
01810
01815 class PLAYERCC_EXPORT Position2dProxy : public ClientProxy
01816 {
01817
01818 private:
01819
01820 void Subscribe(uint32_t aIndex);
01821 void Unsubscribe();
01822
01823
01824 playerc_position2d_t *mDevice;
01825
01826 public:
01827
01829 Position2dProxy(PlayerClient *aPc, uint32_t aIndex=0);
01831 ~Position2dProxy();
01832
01836 void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed);
01837
01840 void SetSpeed(double aXSpeed, double aYawSpeed)
01841 { return SetSpeed(aXSpeed, 0, aYawSpeed);}
01842
01844 void SetSpeed(player_pose2d_t vel)
01845 { return SetSpeed(vel.px, vel.py, vel.pa);}
01846
01850 void SetVelHead(double aXSpeed, double aYSpeed, double aYawHead);
01851
01854 void SetVelHead(double aXSpeed, double aYawHead)
01855 { return SetVelHead(aXSpeed, 0, aYawHead);}
01856
01857
01861 void GoTo(player_pose2d_t pos, player_pose2d_t vel);
01862
01864 void GoTo(player_pose2d_t pos)
01865 { player_pose2d_t vel = {0,0,0}; GoTo(pos, vel); }
01866
01869 void GoTo(double aX, double aY, double aYaw)
01870 { player_pose2d_t pos = {aX,aY,aYaw}; player_pose2d_t vel = {0,0,0}; GoTo(pos, vel); }
01871
01873 void SetCarlike(double aXSpeed, double aDriveAngle);
01874
01877 void RequestGeom();
01878
01880
01881 player_pose3d_t GetOffset()
01882 {
01883 player_pose3d_t p;
01884 scoped_lock_t lock(mPc->mMutex);
01885 p.px = mDevice->pose[0];
01886 p.py = mDevice->pose[1];
01887 p.pyaw = mDevice->pose[2];
01888 return(p);
01889 }
01890
01892 player_bbox3d_t GetSize()
01893 {
01894 player_bbox3d_t b;
01895 scoped_lock_t lock(mPc->mMutex);
01896 b.sl = mDevice->size[0];
01897 b.sw = mDevice->size[1];
01898 return(b);
01899 }
01900
01905 void SetMotorEnable(bool enable);
01906
01907
01908
01909
01910
01911
01912
01913
01914
01915
01916
01918 void ResetOdometry();
01919
01922
01923
01926 void SetOdometry(double aX, double aY, double aYaw);
01927
01929
01930
01932
01933
01936
01937
01938
01939
01940
01941
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01954 double GetXPos() const { return GetVar(mDevice->px); };
01955
01957 double GetYPos() const { return GetVar(mDevice->py); };
01958
01960 double GetYaw() const { return GetVar(mDevice->pa); };
01961
01963 double GetXSpeed() const { return GetVar(mDevice->vx); };
01964
01966 double GetYSpeed() const { return GetVar(mDevice->vy); };
01967
01969 double GetYawSpeed() const { return GetVar(mDevice->va); };
01970
01972 bool GetStall() const { return GetVar(mDevice->stall) != 0 ? true : false; };
01973
01974 };
01975
01982 class PLAYERCC_EXPORT Position3dProxy : public ClientProxy
01983 {
01984
01985 private:
01986
01987 void Subscribe(uint32_t aIndex);
01988 void Unsubscribe();
01989
01990
01991 playerc_position3d_t *mDevice;
01992
01993 public:
01994
01996 Position3dProxy(PlayerClient *aPc, uint32_t aIndex=0);
01998 ~Position3dProxy();
01999
02003 void SetSpeed(double aXSpeed, double aYSpeed, double aZSpeed,
02004 double aRollSpeed, double aPitchSpeed, double aYawSpeed);
02005
02009 void SetSpeed(double aXSpeed, double aYSpeed,
02010 double aZSpeed, double aYawSpeed)
02011 { SetSpeed(aXSpeed,aYSpeed,aZSpeed,0,0,aYawSpeed); }
02012
02014 void SetSpeed(double aXSpeed, double aYSpeed, double aYawSpeed)
02015 { SetSpeed(aXSpeed, aYSpeed, 0, 0, 0, aYawSpeed); }
02016
02019 void SetSpeed(double aXSpeed, double aYawSpeed)
02020 { SetSpeed(aXSpeed,0,0,0,0,aYawSpeed);}
02021
02023 void SetSpeed(player_pose3d_t vel)
02024 { SetSpeed(vel.px,vel.py,vel.pz,vel.proll,vel.ppitch,vel.pyaw);}
02025
02029 void GoTo(player_pose3d_t aPos, player_pose3d_t aVel);
02030
02032 void GoTo(player_pose3d_t aPos)
02033 { player_pose3d_t vel = {0,0,0,0,0,0}; GoTo(aPos, vel); }
02034
02035
02038 void GoTo(double aX, double aY, double aZ,
02039 double aRoll, double aPitch, double aYaw)
02040 { player_pose3d_t pos = {aX,aY,aZ,aRoll,aPitch,aYaw};
02041 player_pose3d_t vel = {0,0,0,0,0,0};
02042 GoTo(pos, vel);
02043 }
02044
02049 void SetMotorEnable(bool aEnable);
02050
02053 void SelectVelocityControl(int aMode);
02054
02056 void ResetOdometry();
02057
02061 void SetOdometry(double aX, double aY, double aZ,
02062 double aRoll, double aPitch, double aYaw);
02063
02066 void RequestGeom();
02067
02068
02069
02070
02071
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02083 double GetXPos() const { return GetVar(mDevice->pos_x); };
02084
02086 double GetYPos() const { return GetVar(mDevice->pos_y); };
02087
02089 double GetZPos() const { return GetVar(mDevice->pos_z); };
02090
02092 double GetRoll() const { return GetVar(mDevice->pos_roll); };
02093
02095 double GetPitch() const { return GetVar(mDevice->pos_pitch); };
02096
02098 double GetYaw() const { return GetVar(mDevice->pos_yaw); };
02099
02101 double GetXSpeed() const { return GetVar(mDevice->vel_x); };
02102
02104 double GetYSpeed() const { return GetVar(mDevice->vel_y); };
02105
02107 double GetZSpeed() const { return GetVar(mDevice->vel_z); };
02108
02110 double GetRollSpeed() const { return GetVar(mDevice->vel_roll); };
02111
02113 double GetPitchSpeed() const { return GetVar(mDevice->vel_pitch); };
02114
02116 double GetYawSpeed() const { return GetVar(mDevice->vel_yaw); };
02117
02119 bool GetStall () const { return GetVar(mDevice->stall) != 0 ? true : false; };
02120 };
02123 class PLAYERCC_EXPORT PowerProxy : public ClientProxy
02124 {
02125 private:
02126
02127 void Subscribe(uint32_t aIndex);
02128 void Unsubscribe();
02129
02130
02131 playerc_power_t *mDevice;
02132
02133 public:
02135 PowerProxy(PlayerClient *aPc, uint32_t aIndex=0);
02137 ~PowerProxy();
02138
02140 double GetCharge() const { return GetVar(mDevice->charge); };
02141
02143 double GetPercent() const {return GetVar(mDevice->percent); };
02144
02146 double GetJoules() const {return GetVar(mDevice->joules); };
02147
02149 double GetWatts() const {return GetVar(mDevice->watts); };
02150
02152 bool GetCharging() const {return GetVar(mDevice->charging) != 0 ? true : false;};
02153
02154
02155 bool IsValid() const {return GetVar(mDevice->valid) != 0 ? true : false;};
02156 };
02157
02164 class PLAYERCC_EXPORT PtzProxy : public ClientProxy
02165 {
02166
02167 private:
02168
02169 void Subscribe(uint32_t aIndex);
02170 void Unsubscribe();
02171
02172
02173 playerc_ptz_t *mDevice;
02174
02175 public:
02177 PtzProxy(PlayerClient *aPc, uint32_t aIndex=0);
02178
02179 ~PtzProxy();
02180
02181 public:
02182
02186 void SetCam(double aPan, double aTilt, double aZoom);
02187
02189 void SetSpeed(double aPanSpeed=0, double aTiltSpeed=0, double aZoomSpeed=0);
02190
02193 void SelectControlMode(uint32_t aMode);
02194
02196 double GetPan() const { return GetVar(mDevice->pan); };
02198 double GetTilt() const { return GetVar(mDevice->tilt); };
02200 double GetZoom() const { return GetVar(mDevice->zoom); };
02201
02203 int GetStatus();
02204
02205
02206 };
02207
02210 class PLAYERCC_EXPORT RangerProxy : public ClientProxy
02211 {
02212 private:
02213
02214 void Subscribe(uint32_t aIndex);
02215 void Unsubscribe();
02216
02217
02218 playerc_ranger_t *mDevice;
02219
02220 public:
02222 RangerProxy(PlayerClient *aPc, uint32_t aIndex=0);
02224 ~RangerProxy();
02225
02227 uint32_t GetElementCount() const { return GetVar(mDevice->element_count); };
02228
02230 player_pose3d_t GetDevicePose() const { return GetVar(mDevice->device_pose); };
02232 player_bbox3d_t GetDeviceSize() const { return GetVar(mDevice->device_size); };
02233
02235 player_pose3d_t GetElementPose(uint32_t aIndex) const;
02237 player_bbox3d_t GetElementSize(uint32_t aIndex) const;
02238
02240 uint32_t GetRangeCount() const { return GetVar(mDevice->ranges_count); };
02242 double GetRange(uint32_t aIndex) const;
02244 double operator[] (uint32_t aIndex) const { return GetRange(aIndex); }
02245
02247 uint32_t GetIntensityCount() const { return GetVar(mDevice->intensities_count); } ;
02249 double GetIntensity(uint32_t aIndex) const;
02250
02253 void SetPower(bool aEnable);
02254
02257 void SetIntensityData(bool aEnable);
02258
02260 void RequestGeom();
02261
02266 void Configure(double aMinAngle,
02267 double aMaxAngle,
02268 double aAngularRes,
02269 double aMinRange,
02270 double aMaxRange,
02271 double aRangeRes,
02272 double aFrequency);
02273
02276 void RequestConfigure();
02277
02279 double GetMinAngle() const { return GetVar(mDevice->min_angle); };
02280
02282 double GetMaxAngle() const { return GetVar(mDevice->max_angle); };
02283
02285 double GetAngularRes() const { return GetVar(mDevice->angular_res); };
02286
02288 double GetMinRange() const { return GetVar(mDevice->min_range); };
02289
02291 double GetMaxRange() const { return GetVar(mDevice->max_range); };
02292
02294 double GetRangeRes() const { return GetVar(mDevice->range_res); };
02295
02297 double GetFrequency() const { return GetVar(mDevice->frequency); };
02298 };
02299
02302 class PLAYERCC_EXPORT RFIDProxy : public ClientProxy
02303 {
02304
02305 private:
02306
02307 void Subscribe(uint32_t aIndex);
02308 void Unsubscribe();
02309
02310
02311 playerc_rfid_t *mDevice;
02312
02313 public:
02315 RFIDProxy(PlayerClient *aPc, uint32_t aIndex=0);
02317 ~RFIDProxy();
02318
02320 uint32_t GetTagsCount() const { return GetVar(mDevice->tags_count); };
02322 playerc_rfidtag_t GetRFIDTag(uint32_t aIndex) const
02323 { return GetVar(mDevice->tags[aIndex]);};
02324
02329 playerc_rfidtag_t operator [](uint32_t aIndex) const
02330 { return(GetRFIDTag(aIndex)); }
02331 };
02332
02337 class PLAYERCC_EXPORT SimulationProxy : public ClientProxy
02338 {
02339 private:
02340
02341 void Subscribe(uint32_t aIndex);
02342 void Unsubscribe();
02343
02344
02345 playerc_simulation_t *mDevice;
02346
02347 public:
02349 SimulationProxy(PlayerClient *aPc, uint32_t aIndex=0);
02351 ~SimulationProxy();
02352
02355 void SetPose2d(char* identifier, double x, double y, double a);
02356
02359 void GetPose2d(char* identifier, double& x, double& y, double& a);
02360
02363 void SetPose3d(char* identifier, double x, double y, double z,
02364 double roll, double pitch, double yaw);
02365
02368 void GetPose3d(char* identifier, double& x, double& y, double& z,
02369 double& roll, double& pitch, double& yaw, double& time);
02370
02372 void GetProperty(char* identifier, char *name, void *value, size_t value_len );
02373
02375 void SetProperty(char* identifier, char *name, void *value, size_t value_len );
02376 };
02377
02378
02384 class PLAYERCC_EXPORT SonarProxy : public ClientProxy
02385 {
02386 private:
02387
02388 void Subscribe(uint32_t aIndex);
02389 void Unsubscribe();
02390
02391
02392 playerc_sonar_t *mDevice;
02393
02394 public:
02396 SonarProxy(PlayerClient *aPc, uint32_t aIndex=0);
02398 ~SonarProxy();
02399
02401 uint32_t GetCount() const { return GetVar(mDevice->scan_count); };
02402
02404 double GetScan(uint32_t aIndex) const
02405 { if (GetVar(mDevice->scan_count) <= (int32_t)aIndex) return -1.0; return GetVar(mDevice->scan[aIndex]); };
02408 double operator [] (uint32_t aIndex) const { return GetScan(aIndex); }
02409
02411 uint32_t GetPoseCount() const { return GetVar(mDevice->pose_count); };
02412
02414 player_pose3d_t GetPose(uint32_t aIndex) const
02415 { return GetVar(mDevice->poses[aIndex]); };
02416
02417
02418
02419
02420
02421
02422
02423
02425 void RequestGeom();
02426 };
02427
02432 class PLAYERCC_EXPORT SpeechProxy : public ClientProxy
02433 {
02434
02435 private:
02436
02437 void Subscribe(uint32_t aIndex);
02438 void Unsubscribe();
02439
02440
02441 playerc_speech_t *mDevice;
02442
02443 public:
02445 SpeechProxy(PlayerClient *aPc, uint32_t aIndex=0);
02447 ~SpeechProxy();
02448
02451 void Say(std::string aStr);
02452 };
02453
02457 class PLAYERCC_EXPORT SpeechRecognitionProxy : public ClientProxy
02458 {
02459 void Subscribe(uint32_t aIndex);
02460 void Unsubscribe();
02461
02463 playerc_speechrecognition_t *mDevice;
02464 public:
02466 SpeechRecognitionProxy(PlayerClient *aPc, uint32_t aIndex=0);
02467 ~SpeechRecognitionProxy();
02469 std::string GetWord(uint32_t aWord) const{
02470 scoped_lock_t lock(mPc->mMutex);
02471 return std::string(mDevice->words[aWord]);
02472 }
02473
02475 uint32_t GetCount(void) const { return GetVar(mDevice->wordCount); }
02476
02479 std::string operator [](uint32_t aWord) { return(GetWord(aWord)); }
02480 };
02481
02485 class PLAYERCC_EXPORT VectorMapProxy : public ClientProxy
02486 {
02487
02488 private:
02489
02490
02491 void Subscribe(uint32_t aIndex);
02492
02493 void Unsubscribe();
02494
02495
02496 playerc_vectormap_t *mDevice;
02497
02498 bool map_info_cached;
02499 public:
02500
02501 VectorMapProxy(PlayerClient *aPc, uint32_t aIndex=0);
02502
02503 ~VectorMapProxy();
02504
02505 void GetMapInfo();
02506 void GetLayerData(unsigned layer_index);
02507
02508 int GetLayerCount() const;
02509 std::vector<std::string> GetLayerNames() const;
02510 int GetFeatureCount(unsigned layer_index) const;
02511 const uint8_t * GetFeatureData(unsigned layer_index, unsigned feature_index) const;
02512 size_t GetFeatureDataCount(unsigned layer_index, unsigned feature_index) const;
02513 };
02514
02517 class PLAYERCC_EXPORT WiFiProxy: public ClientProxy
02518 {
02519
02520 private:
02521
02522 void Subscribe(uint32_t aIndex);
02523 void Unsubscribe();
02524
02525
02526 playerc_wifi_t *mDevice;
02527
02528 public:
02530 WiFiProxy(PlayerClient *aPc, uint32_t aIndex=0);
02532 ~WiFiProxy();
02533
02534 const playerc_wifi_link_t *GetLink(int aLink);
02535
02536 int GetLinkCount() const { return mDevice->link_count; };
02537 char* GetOwnIP() const { return mDevice->ip; };
02538
02539 char* GetLinkIP(int index) const { return (char*) mDevice->links[index].ip; };
02540 char* GetLinkMAC(int index) const { return (char*) mDevice->links[index].mac; };
02541 char* GetLinkESSID(int index) const { return (char*)mDevice->links[index].essid; };
02542 double GetLinkFreq(int index) const {return mDevice->links[index].freq;};
02543 int GetLinkMode(int index) const { return mDevice->links[index].mode; };
02544 int GetLinkEncrypt(int index) const {return mDevice->links[index].encrypt; };
02545 int GetLinkQuality(int index) const { return mDevice->links[index].qual; };
02546 int GetLinkLevel(int index) const {return mDevice->links[index].level; };
02547 int GetLinkNoise(int index) const {return mDevice->links[index].noise; } ;
02548
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577
02578
02579
02580
02581 };
02582
02585 class PLAYERCC_EXPORT WSNProxy : public ClientProxy
02586 {
02587
02588 private:
02589
02590 void Subscribe(uint32_t aIndex);
02591 void Unsubscribe();
02592
02593
02594 playerc_wsn_t *mDevice;
02595
02596 public:
02598 WSNProxy(PlayerClient *aPc, uint32_t aIndex=0);
02600 ~WSNProxy();
02601
02602 uint32_t GetNodeType () const { return GetVar(mDevice->node_type); };
02603 uint32_t GetNodeID () const { return GetVar(mDevice->node_id); };
02604 uint32_t GetNodeParentID() const { return GetVar(mDevice->node_parent_id); };
02605
02606 player_wsn_node_data_t
02607 GetNodeDataPacket() const { return GetVar(mDevice->data_packet); };
02608
02609 void SetDevState(int nodeID, int groupID, int devNr, int value);
02610 void Power(int nodeID, int groupID, int value);
02611 void DataType(int value);
02612 void DataFreq(int nodeID, int groupID, float frequency);
02613 };
02614
02616 }
02617
02618 namespace std
02619 {
02620 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_point_2d_t& c);
02621 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_pose2d_t& c);
02622 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_pose3d_t& c);
02623 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_bbox2d_t& c);
02624 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_bbox3d_t& c);
02625 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_segment_t& c);
02626 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const player_extent2d_t& c);
02627 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const playerc_device_info_t& c);
02628
02629 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ClientProxy& c);
02630 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ActArrayProxy& c);
02631 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::AioProxy& c);
02632 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::AudioProxy& a);
02633
02634 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::BlobfinderProxy& c);
02635 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::BumperProxy& c);
02636 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::CameraProxy& c);
02637 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::DioProxy& c);
02638 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::FiducialProxy& c);
02639 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::GpsProxy& c);
02640 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::GripperProxy& c);
02641 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::ImuProxy& c);
02642 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::IrProxy& c);
02643 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LaserProxy& c);
02644 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LimbProxy& c);
02645 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LinuxjoystickProxy& c);
02646 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LocalizeProxy& c);
02647 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::LogProxy& c);
02648 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::MapProxy& c);
02649 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::OpaqueProxy& c);
02650 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PlannerProxy& c);
02651 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position1dProxy& c);
02652 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position2dProxy& c);
02653 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::Position3dProxy& c);
02654 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PowerProxy& c);
02655 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::PtzProxy& c);
02656 PLAYERCC_EXPORT std::ostream& operator << (std::ostream &os, const PlayerCc::RangerProxy &c);
02657 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SimulationProxy& c);
02658 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SonarProxy& c);
02659 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechProxy& c);
02660 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::SpeechRecognitionProxy& c);
02661 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::VectorMapProxy& c);
02662
02663 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::WiFiProxy& c);
02664 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::RFIDProxy& c);
02665 PLAYERCC_EXPORT std::ostream& operator << (std::ostream& os, const PlayerCc::WSNProxy& c);
02666 }
02667
02668 #endif
02669