Player

• Frontpage
• Contents

User

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

Developer

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

Online

Homepage
Download
Project
Bugs
Help

playerc.h

/*
 *  libplayerc : a Player client library
 *  Copyright (C) Andrew Howard 2002-2003
 *
 *  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,v 1.185.2.9 2007/12/05 21:57:34 gerkey Exp $
 **************************************************************************/


#ifndef PLAYERC_H
#define PLAYERC_H

#include <stdio.h>
#include <sys/types.h>
#include <netinet/in.h>

// Get the message structures from Player
#include <libplayercore/player.h>
#include <libplayercore/playercommon.h>
#include <libplayercore/error.h>
#include <libplayerxdr/playerxdr.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

/***************************************************************************
 * Array sizes
 **************************************************************************/

#define PLAYERC_MAX_DEVICES             PLAYER_MAX_DEVICES
#define PLAYERC_LASER_MAX_SAMPLES       PLAYER_LASER_MAX_SAMPLES
#define PLAYERC_FIDUCIAL_MAX_SAMPLES    PLAYER_FIDUCIAL_MAX_SAMPLES
#define PLAYERC_SONAR_MAX_SAMPLES       PLAYER_SONAR_MAX_SAMPLES
#define PLAYERC_BUMPER_MAX_SAMPLES      PLAYER_BUMPER_MAX_SAMPLES
#define PLAYERC_IR_MAX_SAMPLES          PLAYER_IR_MAX_SAMPLES
#define PLAYERC_BLOBFINDER_MAX_BLOBS    PLAYER_BLOBFINDER_MAX_BLOBS
#define PLAYERC_WIFI_MAX_LINKS          PLAYER_WIFI_MAX_LINKS
#define PLAYERC_RFID_MAX_TAGS           PLAYER_RFID_MAX_TAGS
#define PLAYERC_RFID_MAX_GUID           PLAYER_RFID_MAX_GUID

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

const char *playerc_error_str(void);

const char *playerc_lookup_name(int code);

int playerc_lookup_code(const char *name);

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


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

  int sock;

  uint8_t mode;

  playerc_device_info_t devinfos[PLAYERC_MAX_DEVICES];
  int devinfo_count;

  struct _playerc_device_t *device[32];
  int device_count;

  playerc_client_item_t qitems[512];
  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_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,
                           void *req_data, void *rep_data, int rep_len);

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

void *playerc_client_read(playerc_client_t *client);


void playerc_client_set_request_timeout(playerc_client_t* client, uint 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);

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


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

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

  uint8_t voltages_count;

  float voltages[PLAYER_AIO_MAX_INPUTS];

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

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


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

  uint32_t actuators_count;
  player_actarray_actuator_t actuators_data[PLAYER_ACTARRAY_NUM_ACTUATORS];
  player_actarray_actuatorgeom_t actuators_geom[PLAYER_ACTARRAY_NUM_ACTUATORS];
} 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);

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_speed_cmd(playerc_actarray_t *device, int joint, float speed);

int playerc_actarray_home_cmd(playerc_actarray_t *device, int joint);

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

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


/***************************************************************************/
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[PLAYER_BLOBFINDER_MAX_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[PLAYERC_BUMPER_MAX_SAMPLES];

  int bumper_count;

  uint8_t bumpers[PLAYERC_BUMPER_MAX_SAMPLES];

} 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[PLAYER_CAMERA_IMAGE_SIZE];

} 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_MAX_SAMPLES];

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


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

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

  unsigned char state;
  unsigned char beams;
  int outer_break_beam;
  int inner_break_beam;
  int paddles_open;
  int paddles_closed;
  int paddles_moving;
  int gripper_error;
  int lift_up;
  int lift_down;
  int lift_moving;
  int lift_error;

} 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_set_cmd(playerc_gripper_t *device, uint8_t cmd, uint8_t arg);

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


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



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

  // data
  player_ir_data_t ranges;

  // 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 ranges[PLAYERC_LASER_MAX_SAMPLES];

  double scan[PLAYERC_LASER_MAX_SAMPLES][2];

  player_point_2d_t point[PLAYERC_LASER_MAX_SAMPLES];

  int intensity[PLAYERC_LASER_MAX_SAMPLES];

  int scan_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);

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

int playerc_laser_get_geom(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, uint enable);

int playerc_limb_brakes(playerc_limb_t *device, uint 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[PLAYER_LOCALIZE_MAX_HYPOTHS];

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

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

  int data_count;

  uint8_t data[PLAYER_OPAQUE_MAX_SIZE];
} 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);

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


/***************************************************************************/
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[PLAYER_PLANNER_MAX_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_vel_head(playerc_position2d_t *device,
                                   double vx, double vy, double pa, int state);

int playerc_position2d_set_cmd_pose_with_vel(playerc_position2d_t *device,
                                             player_pose_t pos,
                                             player_pose_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;

} 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_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;

  int pose_count;

  player_pose_t poses[PLAYERC_SONAR_MAX_SAMPLES];

  int scan_count;

  double scan[PLAYERC_SONAR_MAX_SAMPLES];

} 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[PLAYERC_WIFI_MAX_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_property_int(playerc_simulation_t *device,
                                        char* name,
                                        char* property,
                                        int value );
int playerc_simulation_set_property_double(playerc_simulation_t *device,
                                           char* name,
                                           char* property,
                                           double value );
int playerc_simulation_set_property_string(playerc_simulation_t *device,
                                           char* name,
                                           char* property,
                                           char* value );
/***************************************************************************/


/**************************************************************************/
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, const char *);


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

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

  char rawText[PLAYER_SPEECH_RECOGNITION_TEXT_LEN];
  // Just estimating that no more than 20 words will be spoken between updates.
  // Assuming that the longest word is <= 30 characters.
  char words[20][30];
  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_RFID_MAX_GUID];
}  playerc_rfidtag_t;

typedef struct
{
  playerc_device_t info;

  uint16_t tags_count;

  playerc_rfidtag_t tags[PLAYERC_RFID_MAX_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 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