Player

• Frontpage
• Contents

User

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

Developer

• Architecture
• libplayercore
  • interfaces
• libplayerdrivers
  • drivers
• libplayererror
• libplayerutils
• libplayersd
• libplayertcp
• libplayerxdr
• TODO

Online

Homepage
Download
Project
Bugs
Help

playerc.h

/*
 *  libplayerc : a Player client library
 *  Copyright (C) Andrew Howard and contributors 2002-2007
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

/***************************************************************************
 * Desc: Player client
 * Author: Andrew Howard
 * Date: 24 Aug 2001
 # CVS: $Id: playerc.h 6886 2008-07-18 03:15:24Z thjc $
 **************************************************************************/


#ifndef PLAYERC_H
#define PLAYERC_H

#include <netinet/in.h> // need this for struct sockaddr_in
#include <stdio.h>

#include <libplayerc/playercconfig.h>

#ifdef HAVE_GEOS
#ifndef GEOS_VERSION_MAJOR
#include <geos_c.h>
#endif
#else
typedef void * GEOSGeom;
#endif


// Get the message structures from Player
#include <libplayercore/player.h>
#include <libplayercore/playercommon.h>
#include <libplayercore/error.h>
#include <libplayercore/interface_util.h>
#include <libplayerxdr/playerxdr.h>
#include <libplayerxdr/functiontable.h>

#ifndef MIN
  #define MIN(a,b) ((a < b) ? a : b)
#endif
#ifndef MAX
  #define MAX(a,b) ((a > b) ? a : b)
#endif

#ifdef __cplusplus
extern "C" {
#endif


/***************************************************************************
 * Useful constants (re-defined here so SWIG can pick them up easily)
 **************************************************************************/

#define PLAYERC_OPEN_MODE     PLAYER_OPEN_MODE
#define PLAYERC_CLOSE_MODE    PLAYER_CLOSE_MODE
#define PLAYERC_ERROR_MODE    PLAYER_ERROR_MODE


#define PLAYERC_DATAMODE_PUSH PLAYER_DATAMODE_PUSH
#define PLAYERC_DATAMODE_PULL PLAYER_DATAMODE_PULL

#define PLAYERC_TRANSPORT_TCP 1
#define PLAYERC_TRANSPORT_UDP 2

#define PLAYERC_QUEUE_RING_SIZE 512

/***************************************************************************/
/***************************************************************************/

const char *playerc_error_str(void);

//const char *playerc_lookup_name(int code);

//int playerc_lookup_code(const char *name);

int playerc_add_xdr_ftable(playerxdr_function_t *flist, int replace);

/***************************************************************************/


// Forward declare types
struct _playerc_client_t;
struct _playerc_device_t;


// forward declaration to avoid including <sys/poll.h>, which may not be
// available when people are building clients against this lib
struct pollfd;


/***************************************************************************/
// Items in incoming data queue.
typedef struct
{
  player_msghdr_t header;
  void *data;
} playerc_client_item_t;


// Multi-client data
typedef struct
{
  // List of clients being managed
  int client_count;
  struct _playerc_client_t *client[128];

  // Poll info
  struct pollfd* pollfd;

  // Latest time received from any server
  double time;

} playerc_mclient_t;

// Create a multi-client object
playerc_mclient_t *playerc_mclient_create(void);

// Destroy a multi-client object
void playerc_mclient_destroy(playerc_mclient_t *mclient);

// Add a client to the multi-client (private).
int playerc_mclient_addclient(playerc_mclient_t *mclient, struct _playerc_client_t *client);

// Test to see if there is pending data.
// Returns -1 on error, 0 or 1 otherwise.
int playerc_mclient_peek(playerc_mclient_t *mclient, int timeout);

// Read incoming data.  The timeout is in ms.  Set timeout to a
// negative value to wait indefinitely.
int playerc_mclient_read(playerc_mclient_t *mclient, int timeout);

/***************************************************************************/


/***************************************************************************/
typedef void (*playerc_putmsg_fn_t) (void *device, char *header, char *data);

typedef void (*playerc_callback_fn_t) (void *data);


typedef struct
{
  player_devaddr_t addr;

  char drivername[PLAYER_MAX_DRIVER_STRING_LEN];

} playerc_device_info_t;


typedef struct _playerc_client_t
{
  void *id;

  char *host;
  int port;
  int transport;
  struct sockaddr_in server;

  int retry_limit;

  double retry_time;

  uint32_t overflow_count;


  int sock;

  uint8_t mode;

  int data_requested;

  int data_received;


  playerc_device_info_t devinfos[PLAYER_MAX_DEVICES];
  int devinfo_count;

  struct _playerc_device_t *device[PLAYER_MAX_DEVICES];
  int device_count;

  playerc_client_item_t qitems[PLAYERC_QUEUE_RING_SIZE];
  int qfirst, qlen, qsize;

  char *data;
  char *write_xdrdata;
  char *read_xdrdata;
  size_t read_xdrdata_len;


  double datatime;
  double lasttime;

  double request_timeout;

} playerc_client_t;


playerc_client_t *playerc_client_create(playerc_mclient_t *mclient,
                                        const char *host, int port);

void playerc_client_destroy(playerc_client_t *client);

void playerc_client_set_transport(playerc_client_t* client,
                                  unsigned int transport);

int playerc_client_connect(playerc_client_t *client);

int playerc_client_disconnect(playerc_client_t *client);

int playerc_client_disconnect_retry(playerc_client_t *client);

int playerc_client_datamode(playerc_client_t *client, uint8_t mode);

int playerc_client_requestdata(playerc_client_t* client);

int playerc_client_set_replace_rule(playerc_client_t *client, int interf, int index, int type, int subtype, int replace);


int playerc_client_adddevice(playerc_client_t *client, struct _playerc_device_t *device);


int playerc_client_deldevice(playerc_client_t *client, struct _playerc_device_t *device);

int  playerc_client_addcallback(playerc_client_t *client, struct _playerc_device_t *device,
                                playerc_callback_fn_t callback, void *data);

int  playerc_client_delcallback(playerc_client_t *client, struct _playerc_device_t *device,
                                playerc_callback_fn_t callback, void *data);

int playerc_client_get_devlist(playerc_client_t *client);

int playerc_client_subscribe(playerc_client_t *client, int code, int index,
                             int access, char *drivername, size_t len);

int playerc_client_unsubscribe(playerc_client_t *client, int code, int index);

int playerc_client_request(playerc_client_t *client,
                           struct _playerc_device_t *device, uint8_t reqtype,
                           const void *req_data, void **rep_data);

/*int playerc_client_getresponse(playerc_client_t *client, uint16_t device,
    uint16_t index, uint16_t sequence, uint8_t * resptype, uint8_t * resp_data, int resp_len);
*/
int playerc_client_peek(playerc_client_t *client, int timeout);

int playerc_client_internal_peek(playerc_client_t *client, int timeout);

void *playerc_client_read(playerc_client_t *client);

// Read and process a packet (nonblocking)
// returns 0 if no data recieved, 1 if data recieved and -1 on error
int playerc_client_read_nonblock(playerc_client_t *client);
// Read and process a packet (nonblocking), fills in pointer to proxy that got data
// returns 0 if no data recieved, 1 if data recieved and -1 on error
int playerc_client_read_nonblock_withproxy(playerc_client_t *client, void ** proxy);

void playerc_client_set_request_timeout(playerc_client_t* client, uint32_t seconds);

void playerc_client_set_retry_limit(playerc_client_t* client, int limit);

void playerc_client_set_retry_time(playerc_client_t* client, double time);

int playerc_client_write(playerc_client_t *client,
                         struct _playerc_device_t *device,
                         uint8_t subtype,
                         void *cmd, double* timestamp);


/**************************************************************************/


/***************************************************************************/
typedef struct _playerc_device_t
{
  void *id;

  playerc_client_t *client;

  player_devaddr_t addr;

  char drivername[PLAYER_MAX_DRIVER_STRING_LEN];

  int subscribed;

  double datatime;

  double lasttime;

  int fresh;
  int freshgeom;
  int freshconfig;

  playerc_putmsg_fn_t putmsg;

  void *user_data;

  int callback_count;
  playerc_callback_fn_t callback[4];
  void *callback_data[4];

} playerc_device_t;


void playerc_device_init(playerc_device_t *device, playerc_client_t *client,
                         int code, int index, playerc_putmsg_fn_t putmsg);

void playerc_device_term(playerc_device_t *device);

int playerc_device_subscribe(playerc_device_t *device, int access);

int playerc_device_unsubscribe(playerc_device_t *device);

int playerc_device_hascapability(playerc_device_t *device, uint32_t type, uint32_t subtype);

int playerc_device_get_intprop(playerc_device_t *device, char *property, int32_t *value);

int playerc_device_set_intprop(playerc_device_t *device, char *property, int32_t value);

int playerc_device_get_dblprop(playerc_device_t *device, char *property, double *value);

int playerc_device_set_dblprop(playerc_device_t *device, char *property, double value);

int playerc_device_get_strprop(playerc_device_t *device, char *property, char **value);

int playerc_device_set_strprop(playerc_device_t *device, char *property, char *value);


/**************************************************************************/


/***************************************************************************/
/***************************************************************************/

/**************************************************************************/
typedef struct
{
  playerc_device_t info;

  uint8_t voltages_count;

  float *voltages;

} playerc_aio_t;


playerc_aio_t *playerc_aio_create(playerc_client_t *client, int index);

void playerc_aio_destroy(playerc_aio_t *device);

int playerc_aio_subscribe(playerc_aio_t *device, int access);

int playerc_aio_unsubscribe(playerc_aio_t *device);

int playerc_aio_set_output(playerc_aio_t *device, uint8_t id, float volt);

float playerc_aio_get_data(playerc_aio_t *device, uint32_t index);

/***************************************************************************/


/***************************************************************************/
#define PLAYERC_ACTARRAY_NUM_ACTUATORS PLAYER_ACTARRAY_NUM_ACTUATORS
#define PLAYERC_ACTARRAY_ACTSTATE_IDLE PLAYER_ACTARRAY_ACTSTATE_IDLE
#define PLAYERC_ACTARRAY_ACTSTATE_MOVING PLAYER_ACTARRAY_ACTSTATE_MOVING
#define PLAYERC_ACTARRAY_ACTSTATE_BRAKED PLAYER_ACTARRAY_ACTSTATE_BRAKED
#define PLAYERC_ACTARRAY_ACTSTATE_STALLED PLAYER_ACTARRAY_ACTSTATE_STALLED
#define PLAYERC_ACTARRAY_TYPE_LINEAR PLAYER_ACTARRAY_TYPE_LINEAR
#define PLAYERC_ACTARRAY_TYPE_ROTARY PLAYER_ACTARRAY_TYPE_ROTARY


typedef struct
{
  playerc_device_t info;

  uint32_t actuators_count;
  player_actarray_actuator_t *actuators_data;
  uint32_t actuators_geom_count;
  player_actarray_actuatorgeom_t *actuators_geom;
  uint8_t motor_state;
  player_point_3d_t base_pos;
  player_orientation_3d_t base_orientation;
} playerc_actarray_t;

playerc_actarray_t *playerc_actarray_create(playerc_client_t *client, int index);

void playerc_actarray_destroy(playerc_actarray_t *device);

int playerc_actarray_subscribe(playerc_actarray_t *device, int access);

int playerc_actarray_unsubscribe(playerc_actarray_t *device);

player_actarray_actuator_t playerc_actarray_get_actuator_data(playerc_actarray_t *device, int index);

player_actarray_actuatorgeom_t playerc_actarray_get_actuator_geom(playerc_actarray_t *device, int index);

int playerc_actarray_get_geom(playerc_actarray_t *device);

int playerc_actarray_position_cmd(playerc_actarray_t *device, int joint, float position);

int playerc_actarray_multi_position_cmd(playerc_actarray_t *device, float *positions, int positions_count);

int playerc_actarray_speed_cmd(playerc_actarray_t *device, int joint, float speed);

int playerc_actarray_multi_speed_cmd(playerc_actarray_t *device, float *speeds, int speeds_count);

int playerc_actarray_home_cmd(playerc_actarray_t *device, int joint);

int playerc_actarray_current_cmd(playerc_actarray_t *device, int joint, float current);

int playerc_actarray_multi_current_cmd(playerc_actarray_t *device, float *currents, int currents_count);


int playerc_actarray_power(playerc_actarray_t *device, uint8_t enable);

int playerc_actarray_brakes(playerc_actarray_t *device, uint8_t enable);

int playerc_actarray_speed_config(playerc_actarray_t *device, int joint, float speed);

// Set the accelration of a joint (-1 for all joints) for all subsequent movement commands
int playerc_actarray_accel_config(playerc_actarray_t *device, int joint, float accel);


/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  player_audio_mixer_channel_list_detail_t channel_details_list;

  player_audio_wav_t wav_data;

  player_audio_seq_t seq_data;

  player_audio_mixer_channel_list_t mixer_data;

  uint32_t state;

  int last_index;

} playerc_audio_t;

playerc_audio_t *playerc_audio_create(playerc_client_t *client, int index);

void playerc_audio_destroy(playerc_audio_t *device);

int playerc_audio_subscribe(playerc_audio_t *device, int access);

int playerc_audio_unsubscribe(playerc_audio_t *device);

int playerc_audio_wav_play_cmd(playerc_audio_t *device, uint32_t data_count, uint8_t data[], uint32_t format);

int playerc_audio_wav_stream_rec_cmd(playerc_audio_t *device, uint8_t state);

int playerc_audio_sample_play_cmd(playerc_audio_t *device, int index);

int playerc_audio_seq_play_cmd(playerc_audio_t *device, player_audio_seq_t * tones);

int playerc_audio_mixer_multchannels_cmd(playerc_audio_t *device, player_audio_mixer_channel_list_t * levels);

int playerc_audio_mixer_channel_cmd(playerc_audio_t *device, uint32_t index, float amplitude, uint8_t active);

int playerc_audio_wav_rec(playerc_audio_t *device);

int playerc_audio_sample_load(playerc_audio_t *device, int index, uint32_t data_count, uint8_t data[], uint32_t format);

int playerc_audio_sample_retrieve(playerc_audio_t *device, int index);

int playerc_audio_sample_rec(playerc_audio_t *device, int index, uint32_t length);

int playerc_audio_get_mixer_levels(playerc_audio_t *device);

int playerc_audio_get_mixer_details(playerc_audio_t *device);

/**************************************************************************/

#define PLAYERC_BLACKBOARD_DATA_TYPE_NONE       0
#define PLAYERC_BLACKBOARD_DATA_TYPE_SIMPLE     1
#define PLAYERC_BLACKBOARD_DATA_TYPE_COMPLEX    2

#define PLAYERC_BLACKBOARD_DATA_SUBTYPE_NONE    0
#define PLAYERC_BLACKBOARD_DATA_SUBTYPE_STRING  1
#define PLAYERC_BLACKBOARD_DATA_SUBTYPE_INT     2
#define PLAYERC_BLACKBOARD_DATA_SUBTYPE_DOUBLE  3

typedef struct playerc_blackboard
{
  playerc_device_t info;
  void (*on_blackboard_event)(struct playerc_blackboard*, player_blackboard_entry_t);
  void *py_private;
} playerc_blackboard_t;

playerc_blackboard_t *playerc_blackboard_create(playerc_client_t *client, int index);

void playerc_blackboard_destroy(playerc_blackboard_t *device);

int playerc_blackboard_subscribe(playerc_blackboard_t *device, int access);

int playerc_blackboard_unsubscribe(playerc_blackboard_t *device);

int playerc_blackboard_subscribe_to_key(playerc_blackboard_t *device, const char* key, const char* group, player_blackboard_entry_t** entry);

int playerc_blackboard_get_entry(playerc_blackboard_t *device, const char* key, const char* group, player_blackboard_entry_t** entry);

int playerc_blackboard_unsubscribe_from_key(playerc_blackboard_t *device, const char* key, const char* group);

int playerc_blackboard_subscribe_to_group(playerc_blackboard_t *device, const char* group);

int playerc_blackboard_unsubscribe_from_group(playerc_blackboard_t *device, const char* group);

int playerc_blackboard_set_entry(playerc_blackboard_t *device, player_blackboard_entry_t* entry);

int playerc_blackboard_set_string(playerc_blackboard_t *device, const char* key, const char* group, const char* value);

int playerc_blackboard_set_int(playerc_blackboard_t *device, const char* key, const char* group, const int value);

int playerc_blackboard_set_double(playerc_blackboard_t *device, const char* key, const char* group, const double value);

/**************************************************************************/
typedef struct
{
  playerc_device_t info;

  uint32_t enabled;
  double duty_cycle;
  double period;
  uint8_t red, green, blue;
} playerc_blinkenlight_t;


playerc_blinkenlight_t *playerc_blinkenlight_create(playerc_client_t *client, int index);

void playerc_blinkenlight_destroy(playerc_blinkenlight_t *device);

int playerc_blinkenlight_subscribe(playerc_blinkenlight_t *device, int access);

int playerc_blinkenlight_unsubscribe(playerc_blinkenlight_t *device);

int playerc_blinkenlight_enable( playerc_blinkenlight_t *device,
                                 uint32_t enable );

int playerc_blinkenlight_color( playerc_blinkenlight_t *device,
                                uint32_t id,
                                uint8_t red,
                                uint8_t green,
                                uint8_t blue );
int playerc_blinkenlight_blink( playerc_blinkenlight_t *device,
                                uint32_t id,
                                float period,
                                float duty_cycle );
/***************************************************************************/
typedef player_blobfinder_blob_t playerc_blobfinder_blob_t;

typedef struct
{
  playerc_device_t info;

  unsigned int width, height;

  unsigned int blobs_count;
  playerc_blobfinder_blob_t *blobs;

} playerc_blobfinder_t;


playerc_blobfinder_t *playerc_blobfinder_create(playerc_client_t *client, int index);

void playerc_blobfinder_destroy(playerc_blobfinder_t *device);

int playerc_blobfinder_subscribe(playerc_blobfinder_t *device, int access);

int playerc_blobfinder_unsubscribe(playerc_blobfinder_t *device);


/**************************************************************************/


/**************************************************************************/
typedef struct
{
  playerc_device_t info;

  int pose_count;

  player_bumper_define_t *poses;

  int bumper_count;

  uint8_t *bumpers;

} playerc_bumper_t;


playerc_bumper_t *playerc_bumper_create(playerc_client_t *client, int index);

void playerc_bumper_destroy(playerc_bumper_t *device);

int playerc_bumper_subscribe(playerc_bumper_t *device, int access);

int playerc_bumper_unsubscribe(playerc_bumper_t *device);

int playerc_bumper_get_geom(playerc_bumper_t *device);


/***************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int width, height;

  int bpp;

  int format;

  int fdiv;

  int compression;

  int image_count;

  uint8_t *image;

} playerc_camera_t;


playerc_camera_t *playerc_camera_create(playerc_client_t *client, int index);

void playerc_camera_destroy(playerc_camera_t *device);

int playerc_camera_subscribe(playerc_camera_t *device, int access);

int playerc_camera_unsubscribe(playerc_camera_t *device);

void playerc_camera_decompress(playerc_camera_t *device);

void playerc_camera_save(playerc_camera_t *device, const char *filename);

/**************************************************************************/


/**************************************************************************/
typedef struct
{
  playerc_device_t info;

    uint8_t count;

    uint32_t digin;

} playerc_dio_t;


playerc_dio_t *playerc_dio_create(playerc_client_t *client, int index);

void playerc_dio_destroy(playerc_dio_t *device);

int playerc_dio_subscribe(playerc_dio_t *device, int access);

int playerc_dio_unsubscribe(playerc_dio_t *device);

int playerc_dio_set_output(playerc_dio_t *device, uint8_t output_count, uint32_t digout);


/***************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  player_fiducial_geom_t fiducial_geom;

  int fiducials_count;
  player_fiducial_item_t *fiducials;

} playerc_fiducial_t;


playerc_fiducial_t *playerc_fiducial_create(playerc_client_t *client, int index);

void playerc_fiducial_destroy(playerc_fiducial_t *device);

int playerc_fiducial_subscribe(playerc_fiducial_t *device, int access);

int playerc_fiducial_unsubscribe(playerc_fiducial_t *device);

int playerc_fiducial_get_geom(playerc_fiducial_t *device);


/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double utc_time;

  double lat, lon;

  double alt;

  double utm_e, utm_n;

  double hdop;

  double vdop;

  double err_horz, err_vert;

  int quality;

  int sat_count;

} playerc_gps_t;


playerc_gps_t *playerc_gps_create(playerc_client_t *client, int index);

void playerc_gps_destroy(playerc_gps_t *device);

int playerc_gps_subscribe(playerc_gps_t *device, int access);

int playerc_gps_unsubscribe(playerc_gps_t *device);


/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  player_color_t color;

} playerc_graphics2d_t;


playerc_graphics2d_t *playerc_graphics2d_create(playerc_client_t *client, int index);

void playerc_graphics2d_destroy(playerc_graphics2d_t *device);

int playerc_graphics2d_subscribe(playerc_graphics2d_t *device, int access);

int playerc_graphics2d_unsubscribe(playerc_graphics2d_t *device);

int playerc_graphics2d_setcolor(playerc_graphics2d_t *device,
                                player_color_t col );

int playerc_graphics2d_draw_points(playerc_graphics2d_t *device,
           player_point_2d_t pts[],
           int count );

int playerc_graphics2d_draw_polyline(playerc_graphics2d_t *device,
             player_point_2d_t pts[],
             int count );

int playerc_graphics2d_draw_polygon(playerc_graphics2d_t *device,
            player_point_2d_t pts[],
            int count,
            int filled,
            player_color_t fill_color );

int playerc_graphics2d_clear(playerc_graphics2d_t *device );


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  player_color_t color;

} playerc_graphics3d_t;


playerc_graphics3d_t *playerc_graphics3d_create(playerc_client_t *client, int index);

void playerc_graphics3d_destroy(playerc_graphics3d_t *device);

int playerc_graphics3d_subscribe(playerc_graphics3d_t *device, int access);

int playerc_graphics3d_unsubscribe(playerc_graphics3d_t *device);

int playerc_graphics3d_setcolor(playerc_graphics3d_t *device,
                                player_color_t col );

int playerc_graphics3d_draw(playerc_graphics3d_t *device,
           player_graphics3d_draw_mode_t mode,
           player_point_3d_t pts[],
           int count );

int playerc_graphics3d_clear(playerc_graphics3d_t *device );

int playerc_graphics3d_translate(playerc_graphics3d_t *device,
                                 double x, double y, double z );


int playerc_graphics3d_rotate( playerc_graphics3d_t *device,
                               double a, double x, double y, double z );
/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  player_pose3d_t pose;
  player_bbox3d_t outer_size;
  player_bbox3d_t inner_size;
  uint8_t num_beams;
  uint8_t capacity;

  uint8_t state;
  uint32_t beams;
  uint8_t stored;
} playerc_gripper_t;

playerc_gripper_t *playerc_gripper_create(playerc_client_t *client, int index);

void playerc_gripper_destroy(playerc_gripper_t *device);

int playerc_gripper_subscribe(playerc_gripper_t *device, int access);

int playerc_gripper_unsubscribe(playerc_gripper_t *device);

int playerc_gripper_open_cmd(playerc_gripper_t *device);

int playerc_gripper_close_cmd(playerc_gripper_t *device);

int playerc_gripper_stop_cmd(playerc_gripper_t *device);

int playerc_gripper_store_cmd(playerc_gripper_t *device);

int playerc_gripper_retrieve_cmd(playerc_gripper_t *device);

void playerc_gripper_printout(playerc_gripper_t *device, const char* prefix);

int playerc_gripper_get_geom(playerc_gripper_t *device);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
    playerc_device_t info;
    player_health_cpu_t cpu_usage;
    player_health_memory_t mem;
    player_health_memory_t swap;
} playerc_health_t;


playerc_health_t *playerc_health_create(playerc_client_t *client, int index);

void playerc_health_destroy(playerc_health_t *device);

int playerc_health_subscribe(playerc_health_t *device, int access);

int playerc_health_unsubscribe(playerc_health_t *device);


/***************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  // data
  player_ir_data_t data;

  // config
  player_ir_pose_t poses;

} playerc_ir_t;


playerc_ir_t *playerc_ir_create(playerc_client_t *client, int index);

void playerc_ir_destroy(playerc_ir_t *device);

int playerc_ir_subscribe(playerc_ir_t *device, int access);

int playerc_ir_unsubscribe(playerc_ir_t *device);

int playerc_ir_get_geom(playerc_ir_t *device);


/***************************************************************************/



/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double pose[3];
  double size[2];

  double robot_pose[3];

  int intensity_on;

  int scan_count;

  double scan_start;

  double scan_res;

  double range_res;

  double max_range;

  double scanning_frequency;

  double *ranges;

  double (*scan)[2];

  player_point_2d_t *point;

  int *intensity;

  int scan_id;

  int laser_id;

  double min_right;

  double min_left;
} playerc_laser_t;


playerc_laser_t *playerc_laser_create(playerc_client_t *client, int index);

void playerc_laser_destroy(playerc_laser_t *device);

int playerc_laser_subscribe(playerc_laser_t *device, int access);

int playerc_laser_unsubscribe(playerc_laser_t *device);

int playerc_laser_set_config(playerc_laser_t *device,
                             double min_angle, double max_angle,
                             double resolution,
                             double range_res,
                             unsigned char intensity,
                             double scanning_frequency);

int playerc_laser_get_config(playerc_laser_t *device,
                             double *min_angle,
                             double *max_angle,
                             double *resolution,
                             double *range_res,
                             unsigned char *intensity,
                             double *scanning_frequency);

int playerc_laser_get_geom(playerc_laser_t *device);

int playerc_laser_get_id (playerc_laser_t *device);

void playerc_laser_printout( playerc_laser_t * device,
        const char* prefix );

/**************************************************************************/


typedef struct
{
  playerc_device_t info;

  player_limb_data_t data;
  player_limb_geom_req_t geom;
} playerc_limb_t;

playerc_limb_t *playerc_limb_create(playerc_client_t *client, int index);

void playerc_limb_destroy(playerc_limb_t *device);

int playerc_limb_subscribe(playerc_limb_t *device, int access);

int playerc_limb_unsubscribe(playerc_limb_t *device);

int playerc_limb_get_geom(playerc_limb_t *device);

int playerc_limb_home_cmd(playerc_limb_t *device);

int playerc_limb_stop_cmd(playerc_limb_t *device);

int playerc_limb_setpose_cmd(playerc_limb_t *device, float pX, float pY, float pZ, float aX, float aY, float aZ, float oX, float oY, float oZ);

int playerc_limb_setposition_cmd(playerc_limb_t *device, float pX, float pY, float pZ);

int playerc_limb_vecmove_cmd(playerc_limb_t *device, float x, float y, float z, float length);

int playerc_limb_power(playerc_limb_t *device, uint32_t enable);

int playerc_limb_brakes(playerc_limb_t *device, uint32_t enable);

int playerc_limb_speed_config(playerc_limb_t *device, float speed);

/**************************************************************************/


/***************************************************************************/
typedef struct playerc_localize_particle
{
  double pose[3];
  double weight;
} playerc_localize_particle_t;


typedef struct
{
  playerc_device_t info;

  int map_size_x, map_size_y;

  double map_scale;

  int map_tile_x, map_tile_y;

  int8_t *map_cells;

  int pending_count;

  double pending_time;

  int hypoth_count;
  player_localize_hypoth_t *hypoths;

  double mean[3];
  double variance;
  int num_particles;
  playerc_localize_particle_t *particles;

} playerc_localize_t;


playerc_localize_t *playerc_localize_create(playerc_client_t *client, int index);

void playerc_localize_destroy(playerc_localize_t *device);

int playerc_localize_subscribe(playerc_localize_t *device, int access);

int playerc_localize_unsubscribe(playerc_localize_t *device);

int playerc_localize_set_pose(playerc_localize_t *device, double pose[3], double cov[3]);

int playerc_localize_get_particles(playerc_localize_t *device);

/**************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int type;

  int state;
} playerc_log_t;


playerc_log_t *playerc_log_create(playerc_client_t *client, int index);

void playerc_log_destroy(playerc_log_t *device);

int playerc_log_subscribe(playerc_log_t *device, int access);

int playerc_log_unsubscribe(playerc_log_t *device);

int playerc_log_set_write_state(playerc_log_t* device, int state);

int playerc_log_set_read_state(playerc_log_t* device, int state);

int playerc_log_set_read_rewind(playerc_log_t* device);

int playerc_log_get_state(playerc_log_t* device);

int playerc_log_set_filename(playerc_log_t* device, const char* fname);


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double resolution;

  int width, height;

  double origin[2];

  char* cells;

  double vminx, vminy, vmaxx, vmaxy;
  int num_segments;
  player_segment_t* segments;
} playerc_map_t;

#define PLAYERC_MAP_INDEX(dev, i, j) ((dev->width) * (j) + (i))

playerc_map_t *playerc_map_create(playerc_client_t *client, int index);

void playerc_map_destroy(playerc_map_t *device);

int playerc_map_subscribe(playerc_map_t *device, int access);

int playerc_map_unsubscribe(playerc_map_t *device);

int playerc_map_get_map(playerc_map_t* device);

int playerc_map_get_vector(playerc_map_t* device);

/**************************************************************************/

typedef struct
{
  playerc_device_t info;
  uint32_t srid;
  player_extent2d_t extent;
  uint32_t layers_count;
  player_vectormap_layer_data_t** layers_data;
  player_vectormap_layer_info_t** layers_info;
  GEOSGeom geom;

} playerc_vectormap_t;

playerc_vectormap_t *playerc_vectormap_create(playerc_client_t *client, int index);

void playerc_vectormap_destroy(playerc_vectormap_t *device);

int playerc_vectormap_subscribe(playerc_vectormap_t *device, int access);

int playerc_vectormap_unsubscribe(playerc_vectormap_t *device);

int playerc_vectormap_get_map_info(playerc_vectormap_t* device);

int playerc_vectormap_get_layer_data(playerc_vectormap_t *device, unsigned layer_index);

int playerc_vectormap_write_layer(playerc_vectormap_t *device, const player_vectormap_layer_data_t * data);

void playerc_vectormap_cleanup(playerc_vectormap_t *device);

GEOSGeom playerc_vectormap_get_feature_data(playerc_vectormap_t *device, unsigned layer_index, unsigned feature_index);

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int data_count;

  uint8_t *data;
} playerc_opaque_t;

playerc_opaque_t *playerc_opaque_create(playerc_client_t *client, int index);

void playerc_opaque_destroy(playerc_opaque_t *device);

int playerc_opaque_subscribe(playerc_opaque_t *device, int access);

int playerc_opaque_unsubscribe(playerc_opaque_t *device);

int playerc_opaque_cmd(playerc_opaque_t *device, player_opaque_data_t *data);

int playerc_opaque_req(playerc_opaque_t *device, player_opaque_data_t *request, player_opaque_data_t **reply);

/**************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int path_valid;

  int path_done;

  double px, py, pa;

  double gx, gy, ga;

  double wx, wy, wa;

  int curr_waypoint;

  int waypoint_count;

  double (*waypoints)[3];

} playerc_planner_t;

playerc_planner_t *playerc_planner_create(playerc_client_t *client, int index);

void playerc_planner_destroy(playerc_planner_t *device);

int playerc_planner_subscribe(playerc_planner_t *device, int access);

int playerc_planner_unsubscribe(playerc_planner_t *device);

int playerc_planner_set_cmd_pose(playerc_planner_t *device,
                                  double gx, double gy, double ga);

int playerc_planner_get_waypoints(playerc_planner_t *device);

int playerc_planner_enable(playerc_planner_t *device, int state);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double pose[3];
  double size[2];

  double pos;

  double vel;

  int stall;

  int status;

} playerc_position1d_t;

playerc_position1d_t *playerc_position1d_create(playerc_client_t *client,
                                                int index);

void playerc_position1d_destroy(playerc_position1d_t *device);

int playerc_position1d_subscribe(playerc_position1d_t *device, int access);

int playerc_position1d_unsubscribe(playerc_position1d_t *device);

int playerc_position1d_enable(playerc_position1d_t *device, int enable);

int playerc_position1d_get_geom(playerc_position1d_t *device);

int playerc_position1d_set_cmd_vel(playerc_position1d_t *device,
                                   double vel, int state);

int playerc_position1d_set_cmd_pos(playerc_position1d_t *device,
                                   double pos, int state);

int playerc_position1d_set_cmd_pos_with_vel(playerc_position1d_t *device,
                                            double pos, double vel, int state);

int playerc_position1d_set_odom(playerc_position1d_t *device,
                                double odom);

/**************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double pose[3];
  double size[2];

  double px, py, pa;

  double vx, vy, va;

  int stall;

} playerc_position2d_t;

playerc_position2d_t *playerc_position2d_create(playerc_client_t *client,
                                                int index);

void playerc_position2d_destroy(playerc_position2d_t *device);

int playerc_position2d_subscribe(playerc_position2d_t *device, int access);

int playerc_position2d_unsubscribe(playerc_position2d_t *device);

int playerc_position2d_enable(playerc_position2d_t *device, int enable);

int playerc_position2d_get_geom(playerc_position2d_t *device);

int playerc_position2d_set_cmd_vel(playerc_position2d_t *device,
                                   double vx, double vy, double va, int state);

int playerc_position2d_set_cmd_pose_with_vel(playerc_position2d_t *device,
                                             player_pose2d_t pos,
                                             player_pose2d_t vel,
                                             int state);

int playerc_position2d_set_cmd_pose(playerc_position2d_t *device,
                                    double gx, double gy, double ga, int state);

int playerc_position2d_set_cmd_car(playerc_position2d_t *device,
                                    double vx, double a);

int playerc_position2d_set_odom(playerc_position2d_t *device,
                                double ox, double oy, double oa);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double pose[3];
  double size[2];

  double pos_x, pos_y, pos_z;

  double pos_roll, pos_pitch, pos_yaw;

  double vel_x, vel_y, vel_z;

  double vel_roll, vel_pitch, vel_yaw;

  int stall;

} playerc_position3d_t;


playerc_position3d_t *playerc_position3d_create(playerc_client_t *client,
                                                int index);

void playerc_position3d_destroy(playerc_position3d_t *device);

int playerc_position3d_subscribe(playerc_position3d_t *device, int access);

int playerc_position3d_unsubscribe(playerc_position3d_t *device);

int playerc_position3d_enable(playerc_position3d_t *device, int enable);

int playerc_position3d_get_geom(playerc_position3d_t *device);

int playerc_position3d_set_velocity(playerc_position3d_t *device,
                                    double vx, double vy, double vz,
                                    double vr, double vp, double vt,
                                    int state);

int playerc_position3d_set_speed(playerc_position3d_t *device,
                                 double vx, double vy, double vz, int state);

int playerc_position3d_set_pose(playerc_position3d_t *device,
                                double gx, double gy, double gz,
                                double gr, double gp, double gt);


int playerc_position3d_set_pose_with_vel(playerc_position3d_t *device,
                                         player_pose3d_t pos,
                                         player_pose3d_t vel);

int playerc_position3d_set_cmd_pose(playerc_position3d_t *device,
                                    double gx, double gy, double gz);

int playerc_position3d_set_vel_mode(playerc_position3d_t *device, int mode);

int playerc_position3d_set_odom(playerc_position3d_t *device,
                                double ox, double oy, double oz,
                                double oroll, double opitch, double oyaw);

int playerc_position3d_reset_odom(playerc_position3d_t *device);

/**************************************************************************/


/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int valid;

  double charge;

  double percent;

  double joules;

  double watts;

  int charging;

} playerc_power_t;


playerc_power_t *playerc_power_create(playerc_client_t *client, int index);

void playerc_power_destroy(playerc_power_t *device);

int playerc_power_subscribe(playerc_power_t *device, int access);

int playerc_power_unsubscribe(playerc_power_t *device);


/**************************************************************************/



/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  double pan, tilt;

  double zoom;

  int status;
} playerc_ptz_t;


playerc_ptz_t *playerc_ptz_create(playerc_client_t *client, int index);

void playerc_ptz_destroy(playerc_ptz_t *device);

int playerc_ptz_subscribe(playerc_ptz_t *device, int access);

int playerc_ptz_unsubscribe(playerc_ptz_t *device);

int playerc_ptz_set(playerc_ptz_t *device, double pan, double tilt, double zoom);

int playerc_ptz_query_status(playerc_ptz_t *device);

int playerc_ptz_set_ws(playerc_ptz_t *device, double pan, double tilt, double zoom,
                       double panspeed, double tiltspeed);

int playerc_ptz_set_control_mode(playerc_ptz_t *device, int mode);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  uint32_t sensor_count;

  double min_angle;
  double max_angle;
  double resolution;
  double max_range;
  double range_res;
  double frequency;

  player_pose3d_t device_pose;
  player_bbox3d_t device_size;
  player_pose3d_t *sensor_poses;
  player_bbox3d_t *sensor_sizes;

  uint32_t ranges_count;
  double *ranges;

  uint32_t intensities_count;
  double *intensities;

  uint32_t bearings_count;
  double *bearings;

  uint32_t points_count;
  player_point_3d_t *points;

} playerc_ranger_t;

playerc_ranger_t *playerc_ranger_create(playerc_client_t *client, int index);

void playerc_ranger_destroy(playerc_ranger_t *device);

int playerc_ranger_subscribe(playerc_ranger_t *device, int access);

int playerc_ranger_unsubscribe(playerc_ranger_t *device);

int playerc_ranger_get_geom(playerc_ranger_t *device);

int playerc_ranger_power_config(playerc_ranger_t *device, uint8_t value);

int playerc_ranger_intns_config(playerc_ranger_t *device, uint8_t value);

int playerc_ranger_set_config(playerc_ranger_t *device, double min_angle,
                              double max_angle, double resolution,
                              double max_range, double range_res,
                              double frequency);

int playerc_ranger_get_config(playerc_ranger_t *device, double *min_angle,
                              double *max_angle, double *resolution,
                              double *max_range, double *range_res,
                              double *frequency);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

  int pose_count;

  player_pose3d_t *poses;

  int scan_count;

  double *scan;

} playerc_sonar_t;


playerc_sonar_t *playerc_sonar_create(playerc_client_t *client, int index);

void playerc_sonar_destroy(playerc_sonar_t *device);

int playerc_sonar_subscribe(playerc_sonar_t *device, int access);

int playerc_sonar_unsubscribe(playerc_sonar_t *device);

int playerc_sonar_get_geom(playerc_sonar_t *device);

/**************************************************************************/

/***************************************************************************/
typedef struct
{
  uint8_t mac[32];

  uint8_t ip[32];

  uint8_t essid[32];

  int mode;

  int encrypt;

  double freq;

  int qual, level, noise;

} playerc_wifi_link_t;


typedef struct
{
  playerc_device_t info;

  playerc_wifi_link_t *links;
  int link_count;
  char ip[32];
} playerc_wifi_t;


playerc_wifi_t *playerc_wifi_create(playerc_client_t *client, int index);

void playerc_wifi_destroy(playerc_wifi_t *device);

int playerc_wifi_subscribe(playerc_wifi_t *device, int access);

int playerc_wifi_unsubscribe(playerc_wifi_t *device);

playerc_wifi_link_t *playerc_wifi_get_link(playerc_wifi_t *device, int link);


/**************************************************************************/

/***************************************************************************/
typedef struct
{
  playerc_device_t info;

} playerc_simulation_t;


playerc_simulation_t *playerc_simulation_create(playerc_client_t *client, int index);

void playerc_simulation_destroy(playerc_simulation_t *device);

int playerc_simulation_subscribe(playerc_simulation_t *device, int access);

int playerc_simulation_unsubscribe(playerc_simulation_t *device);

int playerc_simulation_set_pose2d(playerc_simulation_t *device, char* name,
                                  double gx, double gy, double ga);

int playerc_simulation_get_pose2d(playerc_simulation_t *device, char* identifier,
                                  double *x, double *y, double *a);

int playerc_simulation_set_pose3d(playerc_simulation_t *device, char* name,
                                  double gx, double gy, double gz,
                                  double groll, double gpitch, double gyaw);

int playerc_simulation_get_pose3d(playerc_simulation_t *device, char* identifier,
                                  double *x, double *y, double *z,
                                  double *roll, double *pitch, double *yaw, double *time);

int playerc_simulation_set_property(playerc_simulation_t *device,
                                    char* name,
                                    char* property,
                                    void* value,
                                    size_t value_len);

int playerc_simulation_get_property(playerc_simulation_t *device,
                                    char* name,
                                    char* property,
                                    void* value,
                                    size_t value_len);
/***************************************************************************/


/**************************************************************************/
typedef struct
{
  playerc_device_t info;
} playerc_speech_t;


playerc_speech_t *playerc_speech_create(playerc_client_t *client, int index);

void playerc_speech_destroy(playerc_speech_t *device);

int playerc_speech_subscribe(playerc_speech_t *device, int access);

int playerc_speech_unsubscribe(playerc_speech_t *device);

int playerc_speech_say (playerc_speech_t *device, char *);


/***************************************************************************/

/**************************************************************************/
typedef struct
{
  playerc_device_t info;

  char *rawText;
  // Just estimating that no more than 20 words will be spoken between updates.
  // Assuming that the longest word is <= 30 characters.
  char **words;
  int wordCount;
} playerc_speechrecognition_t;


playerc_speechrecognition_t *playerc_speechrecognition_create(playerc_client_t *client, int index);

void playerc_speechrecognition_destroy(playerc_speechrecognition_t *device);

int playerc_speechrecognition_subscribe(playerc_speechrecognition_t *device, int access);

int playerc_speechrecognition_unsubscribe(playerc_speechrecognition_t *device);

/***************************************************************************/

/**************************************************************************/
typedef struct
{
    uint32_t type;
    uint32_t guid_count;
    uint8_t *guid;
}  playerc_rfidtag_t;

typedef struct
{
  playerc_device_t info;

  uint16_t tags_count;

  playerc_rfidtag_t *tags;
} playerc_rfid_t;


playerc_rfid_t *playerc_rfid_create(playerc_client_t *client, int index);

void playerc_rfid_destroy(playerc_rfid_t *device);

int playerc_rfid_subscribe(playerc_rfid_t *device, int access);

int playerc_rfid_unsubscribe(playerc_rfid_t *device);

/***************************************************************************/

/**************************************************************************/
typedef player_pointcloud3d_element_t playerc_pointcloud3d_element_t;

typedef struct
{
  playerc_device_t info;

  uint16_t points_count;

  playerc_pointcloud3d_element_t *points;
} playerc_pointcloud3d_t;


playerc_pointcloud3d_t *playerc_pointcloud3d_create (playerc_client_t *client, int index);

void playerc_pointcloud3d_destroy (playerc_pointcloud3d_t *device);

int playerc_pointcloud3d_subscribe (playerc_pointcloud3d_t *device, int access);

int playerc_pointcloud3d_unsubscribe (playerc_pointcloud3d_t *device);

/***************************************************************************/

/**************************************************************************/
typedef struct
{
    playerc_device_t info;

    player_pose3d_t pose;

    player_imu_data_calib_t calib_data;

    float q0, q1, q2, q3;
} playerc_imu_t;

playerc_imu_t *playerc_imu_create (playerc_client_t *client, int index);

void playerc_imu_destroy (playerc_imu_t *device);

int playerc_imu_subscribe (playerc_imu_t *device, int access);

int playerc_imu_unsubscribe (playerc_imu_t *device);

int playerc_imu_datatype (playerc_imu_t *device, int value);

int playerc_imu_reset_orientation (playerc_imu_t *device, int value);

/***************************************************************************/

/**************************************************************************/
typedef struct
{
    playerc_device_t info;

    uint32_t node_type;
    uint32_t node_id;
    uint32_t node_parent_id;
    player_wsn_node_data_t data_packet;
} playerc_wsn_t;


playerc_wsn_t *playerc_wsn_create(playerc_client_t *client, int index);

void playerc_wsn_destroy(playerc_wsn_t *device);

int playerc_wsn_subscribe(playerc_wsn_t *device, int access);

int playerc_wsn_unsubscribe(playerc_wsn_t *device);

int playerc_wsn_set_devstate(playerc_wsn_t *device, int node_id,
                             int group_id, int devnr, int state);

int playerc_wsn_power(playerc_wsn_t *device, int node_id, int group_id,
                      int value);

int playerc_wsn_datatype(playerc_wsn_t *device, int value);

int playerc_wsn_datafreq(playerc_wsn_t *device, int node_id, int group_id,
                         double frequency);

/***************************************************************************/

#ifdef __cplusplus
}
#endif

#endif

---

Last updated 12 September 2005 21:38:45