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 8173 2009-08-04 07:25:00Z gbiggs $
**************************************************************************/
#ifndef PLAYERC_H
#define PLAYERC_H
#if !defined (WIN32)
#include <netinet/in.h> /* need this for struct sockaddr_in */
#endif
#include <stddef.h> /* size_t */
#include <stdio.h>
#include <playerconfig.h>
/* Get the message structures from Player*/
#include <libplayercommon/playercommon.h>
#include <libplayerinterface/player.h>
#include <libplayercommon/playercommon.h>
#include <libplayerinterface/interface_util.h>
#include <libplayerinterface/playerxdr.h>
#include <libplayerinterface/functiontable.h>
#include <libplayerwkb/playerwkb.h>
#if defined (WIN32)
#include <winsock2.h>
#endif
#ifndef MIN
#define MIN(a,b) ((a < b) ? a : b)
#endif
#ifndef MAX
#define MAX(a,b) ((a > b) ? a : b)
#endif
#if defined (WIN32)
#if defined (PLAYER_STATIC)
#define PLAYERC_EXPORT
#elif defined (playerc_EXPORTS)
#define PLAYERC_EXPORT __declspec (dllexport)
#else
#define PLAYERC_EXPORT __declspec (dllimport)
#endif
#else
#define PLAYERC_EXPORT
#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
/***************************************************************************/
/***************************************************************************/
PLAYERC_EXPORT const char *playerc_error_str(void);
/*const char *playerc_lookup_name(int code);*/
/*int playerc_lookup_code(const char *name);*/
PLAYERC_EXPORT 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_EXPORT playerc_mclient_t *playerc_mclient_create(void);
/* Destroy a multi-client object*/
PLAYERC_EXPORT void playerc_mclient_destroy(playerc_mclient_t *mclient);
/* Add a client to the multi-client (private).*/
PLAYERC_EXPORT 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.*/
PLAYERC_EXPORT 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.*/
PLAYERC_EXPORT int playerc_mclient_read(playerc_mclient_t *mclient, int timeout);
/***************************************************************************/
/***************************************************************************/
PLAYERC_EXPORT typedef void (*playerc_putmsg_fn_t) (void *device, char *header, char *data);
PLAYERC_EXPORT 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 connected;
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_EXPORT playerc_client_t *playerc_client_create(playerc_mclient_t *mclient,
const char *host, int port);
PLAYERC_EXPORT void playerc_client_destroy(playerc_client_t *client);
PLAYERC_EXPORT void playerc_client_set_transport(playerc_client_t* client,
unsigned int transport);
PLAYERC_EXPORT int playerc_client_connect(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_disconnect(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_disconnect_retry(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_datamode(playerc_client_t *client, uint8_t mode);
PLAYERC_EXPORT int playerc_client_requestdata(playerc_client_t* client);
PLAYERC_EXPORT int playerc_client_set_replace_rule(playerc_client_t *client, int interf, int index, int type, int subtype, int replace);
PLAYERC_EXPORT int playerc_client_adddevice(playerc_client_t *client, struct _playerc_device_t *device);
PLAYERC_EXPORT int playerc_client_deldevice(playerc_client_t *client, struct _playerc_device_t *device);
PLAYERC_EXPORT int playerc_client_addcallback(playerc_client_t *client, struct _playerc_device_t *device,
playerc_callback_fn_t callback, void *data);
PLAYERC_EXPORT int playerc_client_delcallback(playerc_client_t *client, struct _playerc_device_t *device,
playerc_callback_fn_t callback, void *data);
PLAYERC_EXPORT int playerc_client_get_devlist(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_subscribe(playerc_client_t *client, int code, int index,
int access, char *drivername, size_t len);
PLAYERC_EXPORT int playerc_client_unsubscribe(playerc_client_t *client, int code, int index);
PLAYERC_EXPORT 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);
*/
PLAYERC_EXPORT int playerc_client_peek(playerc_client_t *client, int timeout);
PLAYERC_EXPORT int playerc_client_internal_peek(playerc_client_t *client, int timeout);
PLAYERC_EXPORT void *playerc_client_read(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_read_nonblock(playerc_client_t *client);
PLAYERC_EXPORT int playerc_client_read_nonblock_withproxy(playerc_client_t *client, void ** proxy);
PLAYERC_EXPORT void playerc_client_set_request_timeout(playerc_client_t* client, uint32_t seconds);
PLAYERC_EXPORT void playerc_client_set_retry_limit(playerc_client_t* client, int limit);
PLAYERC_EXPORT void playerc_client_set_retry_time(playerc_client_t* client, double time);
PLAYERC_EXPORT 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;
PLAYERC_EXPORT void playerc_device_init(playerc_device_t *device, playerc_client_t *client,
int code, int index, playerc_putmsg_fn_t putmsg);
PLAYERC_EXPORT void playerc_device_term(playerc_device_t *device);
PLAYERC_EXPORT int playerc_device_subscribe(playerc_device_t *device, int access);
PLAYERC_EXPORT int playerc_device_unsubscribe(playerc_device_t *device);
PLAYERC_EXPORT int playerc_device_hascapability(playerc_device_t *device, uint32_t type, uint32_t subtype);
PLAYERC_EXPORT int playerc_device_get_boolprop(playerc_device_t *device, char *property, BOOL *value);
PLAYERC_EXPORT int playerc_device_set_boolprop(playerc_device_t *device, char *property, BOOL value);
PLAYERC_EXPORT int playerc_device_get_intprop(playerc_device_t *device, char *property, int32_t *value);
PLAYERC_EXPORT int playerc_device_set_intprop(playerc_device_t *device, char *property, int32_t value);
PLAYERC_EXPORT int playerc_device_get_dblprop(playerc_device_t *device, char *property, double *value);
PLAYERC_EXPORT int playerc_device_set_dblprop(playerc_device_t *device, char *property, double value);
PLAYERC_EXPORT int playerc_device_get_strprop(playerc_device_t *device, char *property, char **value);
PLAYERC_EXPORT int playerc_device_set_strprop(playerc_device_t *device, char *property, char *value);
/**************************************************************************/
/***************************************************************************/
/***************************************************************************/
/**************************************************************************/
typedef struct
{
playerc_device_t info;
/* The number of valid analog inputs.*/
uint8_t voltages_count;
/* A bitfield of the current digital inputs.*/
float *voltages;
} playerc_aio_t;
PLAYERC_EXPORT playerc_aio_t *playerc_aio_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_aio_destroy(playerc_aio_t *device);
PLAYERC_EXPORT int playerc_aio_subscribe(playerc_aio_t *device, int access);
PLAYERC_EXPORT int playerc_aio_unsubscribe(playerc_aio_t *device);
PLAYERC_EXPORT int playerc_aio_set_output(playerc_aio_t *device, uint8_t id, float volt);
PLAYERC_EXPORT 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_EXPORT playerc_actarray_t *playerc_actarray_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_actarray_destroy(playerc_actarray_t *device);
PLAYERC_EXPORT int playerc_actarray_subscribe(playerc_actarray_t *device, int access);
PLAYERC_EXPORT int playerc_actarray_unsubscribe(playerc_actarray_t *device);
PLAYERC_EXPORT player_actarray_actuator_t playerc_actarray_get_actuator_data(playerc_actarray_t *device, uint32_t index);
PLAYERC_EXPORT player_actarray_actuatorgeom_t playerc_actarray_get_actuator_geom(playerc_actarray_t *device, uint32_t index);
PLAYERC_EXPORT int playerc_actarray_get_geom(playerc_actarray_t *device);
PLAYERC_EXPORT int playerc_actarray_position_cmd(playerc_actarray_t *device, int joint, float position);
PLAYERC_EXPORT int playerc_actarray_multi_position_cmd(playerc_actarray_t *device, float *positions, int positions_count);
PLAYERC_EXPORT int playerc_actarray_speed_cmd(playerc_actarray_t *device, int joint, float speed);
PLAYERC_EXPORT int playerc_actarray_multi_speed_cmd(playerc_actarray_t *device, float *speeds, int speeds_count);
PLAYERC_EXPORT int playerc_actarray_home_cmd(playerc_actarray_t *device, int joint);
PLAYERC_EXPORT int playerc_actarray_current_cmd(playerc_actarray_t *device, int joint, float current);
PLAYERC_EXPORT int playerc_actarray_multi_current_cmd(playerc_actarray_t *device, float *currents, int currents_count);
PLAYERC_EXPORT int playerc_actarray_power(playerc_actarray_t *device, uint8_t enable);
PLAYERC_EXPORT int playerc_actarray_brakes(playerc_actarray_t *device, uint8_t enable);
PLAYERC_EXPORT 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*/
PLAYERC_EXPORT 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_EXPORT playerc_audio_t *playerc_audio_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_audio_destroy(playerc_audio_t *device);
PLAYERC_EXPORT int playerc_audio_subscribe(playerc_audio_t *device, int access);
PLAYERC_EXPORT int playerc_audio_unsubscribe(playerc_audio_t *device);
PLAYERC_EXPORT int playerc_audio_wav_play_cmd(playerc_audio_t *device, uint32_t data_count, uint8_t data[], uint32_t format);
PLAYERC_EXPORT int playerc_audio_wav_stream_rec_cmd(playerc_audio_t *device, uint8_t state);
PLAYERC_EXPORT int playerc_audio_sample_play_cmd(playerc_audio_t *device, int index);
PLAYERC_EXPORT int playerc_audio_seq_play_cmd(playerc_audio_t *device, player_audio_seq_t * tones);
PLAYERC_EXPORT int playerc_audio_mixer_multchannels_cmd(playerc_audio_t *device, player_audio_mixer_channel_list_t * levels);
PLAYERC_EXPORT int playerc_audio_mixer_channel_cmd(playerc_audio_t *device, uint32_t index, float amplitude, uint8_t active);
PLAYERC_EXPORT int playerc_audio_wav_rec(playerc_audio_t *device);
PLAYERC_EXPORT int playerc_audio_sample_load(playerc_audio_t *device, int index, uint32_t data_count, uint8_t data[], uint32_t format);
PLAYERC_EXPORT int playerc_audio_sample_retrieve(playerc_audio_t *device, int index);
PLAYERC_EXPORT int playerc_audio_sample_rec(playerc_audio_t *device, int index, uint32_t length);
PLAYERC_EXPORT int playerc_audio_get_mixer_levels(playerc_audio_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_blackboard_t *playerc_blackboard_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_blackboard_destroy(playerc_blackboard_t *device);
PLAYERC_EXPORT int playerc_blackboard_subscribe(playerc_blackboard_t *device, int access);
PLAYERC_EXPORT int playerc_blackboard_unsubscribe(playerc_blackboard_t *device);
PLAYERC_EXPORT int playerc_blackboard_subscribe_to_key(playerc_blackboard_t *device, const char* key, const char* group, player_blackboard_entry_t** entry);
PLAYERC_EXPORT int playerc_blackboard_get_entry(playerc_blackboard_t *device, const char* key, const char* group, player_blackboard_entry_t** entry);
PLAYERC_EXPORT int playerc_blackboard_unsubscribe_from_key(playerc_blackboard_t *device, const char* key, const char* group);
PLAYERC_EXPORT int playerc_blackboard_subscribe_to_group(playerc_blackboard_t *device, const char* group);
PLAYERC_EXPORT int playerc_blackboard_unsubscribe_from_group(playerc_blackboard_t *device, const char* group);
PLAYERC_EXPORT int playerc_blackboard_set_entry(playerc_blackboard_t *device, player_blackboard_entry_t* entry);
PLAYERC_EXPORT int playerc_blackboard_set_string(playerc_blackboard_t *device, const char* key, const char* group, const char* value);
PLAYERC_EXPORT int playerc_blackboard_set_int(playerc_blackboard_t *device, const char* key, const char* group, const int value);
PLAYERC_EXPORT 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_EXPORT playerc_blinkenlight_t *playerc_blinkenlight_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_blinkenlight_destroy(playerc_blinkenlight_t *device);
PLAYERC_EXPORT int playerc_blinkenlight_subscribe(playerc_blinkenlight_t *device, int access);
PLAYERC_EXPORT int playerc_blinkenlight_unsubscribe(playerc_blinkenlight_t *device);
PLAYERC_EXPORT int playerc_blinkenlight_enable( playerc_blinkenlight_t *device,
uint32_t enable );
PLAYERC_EXPORT int playerc_blinkenlight_color( playerc_blinkenlight_t *device,
uint32_t id,
uint8_t red,
uint8_t green,
uint8_t blue );
PLAYERC_EXPORT 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_EXPORT playerc_blobfinder_t *playerc_blobfinder_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_blobfinder_destroy(playerc_blobfinder_t *device);
PLAYERC_EXPORT int playerc_blobfinder_subscribe(playerc_blobfinder_t *device, int access);
PLAYERC_EXPORT 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_EXPORT playerc_bumper_t *playerc_bumper_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_bumper_destroy(playerc_bumper_t *device);
PLAYERC_EXPORT int playerc_bumper_subscribe(playerc_bumper_t *device, int access);
PLAYERC_EXPORT int playerc_bumper_unsubscribe(playerc_bumper_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_camera_t *playerc_camera_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_camera_destroy(playerc_camera_t *device);
PLAYERC_EXPORT int playerc_camera_subscribe(playerc_camera_t *device, int access);
PLAYERC_EXPORT int playerc_camera_unsubscribe(playerc_camera_t *device);
PLAYERC_EXPORT void playerc_camera_decompress(playerc_camera_t *device);
PLAYERC_EXPORT void playerc_camera_save(playerc_camera_t *device, const char *filename);
/**************************************************************************/
/**************************************************************************/
typedef struct
{
playerc_device_t info;
/*/ The number of valid digital inputs.*/
uint8_t count;
/*/ A bitfield of the current digital inputs.*/
uint32_t digin;
} playerc_dio_t;
PLAYERC_EXPORT playerc_dio_t *playerc_dio_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_dio_destroy(playerc_dio_t *device);
PLAYERC_EXPORT int playerc_dio_subscribe(playerc_dio_t *device, int access);
PLAYERC_EXPORT int playerc_dio_unsubscribe(playerc_dio_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_fiducial_t *playerc_fiducial_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_fiducial_destroy(playerc_fiducial_t *device);
PLAYERC_EXPORT int playerc_fiducial_subscribe(playerc_fiducial_t *device, int access);
PLAYERC_EXPORT int playerc_fiducial_unsubscribe(playerc_fiducial_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_gps_t *playerc_gps_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_gps_destroy(playerc_gps_t *device);
PLAYERC_EXPORT int playerc_gps_subscribe(playerc_gps_t *device, int access);
PLAYERC_EXPORT int playerc_gps_unsubscribe(playerc_gps_t *device);
/**************************************************************************/
/***************************************************************************/
typedef struct
{
playerc_device_t info;
player_color_t color;
} playerc_graphics2d_t;
PLAYERC_EXPORT playerc_graphics2d_t *playerc_graphics2d_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_graphics2d_destroy(playerc_graphics2d_t *device);
PLAYERC_EXPORT int playerc_graphics2d_subscribe(playerc_graphics2d_t *device, int access);
PLAYERC_EXPORT int playerc_graphics2d_unsubscribe(playerc_graphics2d_t *device);
PLAYERC_EXPORT int playerc_graphics2d_setcolor(playerc_graphics2d_t *device,
player_color_t col );
PLAYERC_EXPORT int playerc_graphics2d_draw_points(playerc_graphics2d_t *device,
player_point_2d_t pts[],
int count );
PLAYERC_EXPORT int playerc_graphics2d_draw_polyline(playerc_graphics2d_t *device,
player_point_2d_t pts[],
int count );
PLAYERC_EXPORT int playerc_graphics2d_draw_polygon(playerc_graphics2d_t *device,
player_point_2d_t pts[],
int count,
int filled,
player_color_t fill_color );
PLAYERC_EXPORT int playerc_graphics2d_clear(playerc_graphics2d_t *device );
/***************************************************************************/
typedef struct
{
playerc_device_t info;
player_color_t color;
} playerc_graphics3d_t;
PLAYERC_EXPORT playerc_graphics3d_t *playerc_graphics3d_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_graphics3d_destroy(playerc_graphics3d_t *device);
PLAYERC_EXPORT int playerc_graphics3d_subscribe(playerc_graphics3d_t *device, int access);
PLAYERC_EXPORT int playerc_graphics3d_unsubscribe(playerc_graphics3d_t *device);
PLAYERC_EXPORT int playerc_graphics3d_setcolor(playerc_graphics3d_t *device,
player_color_t col );
PLAYERC_EXPORT int playerc_graphics3d_draw(playerc_graphics3d_t *device,
player_graphics3d_draw_mode_t mode,
player_point_3d_t pts[],
int count );
PLAYERC_EXPORT int playerc_graphics3d_clear(playerc_graphics3d_t *device );
PLAYERC_EXPORT int playerc_graphics3d_translate(playerc_graphics3d_t *device,
double x, double y, double z );
PLAYERC_EXPORT 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_EXPORT playerc_gripper_t *playerc_gripper_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_gripper_destroy(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_subscribe(playerc_gripper_t *device, int access);
PLAYERC_EXPORT int playerc_gripper_unsubscribe(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_open_cmd(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_close_cmd(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_stop_cmd(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_store_cmd(playerc_gripper_t *device);
PLAYERC_EXPORT int playerc_gripper_retrieve_cmd(playerc_gripper_t *device);
PLAYERC_EXPORT void playerc_gripper_printout(playerc_gripper_t *device, const char* prefix);
PLAYERC_EXPORT 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_EXPORT playerc_health_t *playerc_health_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_health_destroy(playerc_health_t *device);
PLAYERC_EXPORT int playerc_health_subscribe(playerc_health_t *device, int access);
PLAYERC_EXPORT 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_EXPORT playerc_ir_t *playerc_ir_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_ir_destroy(playerc_ir_t *device);
PLAYERC_EXPORT int playerc_ir_subscribe(playerc_ir_t *device, int access);
PLAYERC_EXPORT int playerc_ir_unsubscribe(playerc_ir_t *device);
PLAYERC_EXPORT int playerc_ir_get_geom(playerc_ir_t *device);
/***************************************************************************/
/***************************************************************************/
typedef struct
{
playerc_device_t info;
int32_t axes_count;
int32_t pos[8];
uint32_t buttons;
int * axes_max;
int * axes_min;
double * scale_pos;
} playerc_joystick_t;
PLAYERC_EXPORT playerc_joystick_t *playerc_joystick_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_joystick_destroy(playerc_joystick_t *device);
PLAYERC_EXPORT int playerc_joystick_subscribe(playerc_joystick_t *device, int access);
PLAYERC_EXPORT int playerc_joystick_unsubscribe(playerc_joystick_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_EXPORT playerc_laser_t *playerc_laser_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_laser_destroy(playerc_laser_t *device);
PLAYERC_EXPORT int playerc_laser_subscribe(playerc_laser_t *device, int access);
PLAYERC_EXPORT int playerc_laser_unsubscribe(playerc_laser_t *device);
PLAYERC_EXPORT 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);
PLAYERC_EXPORT 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);
PLAYERC_EXPORT int playerc_laser_get_geom(playerc_laser_t *device);
PLAYERC_EXPORT int playerc_laser_get_id (playerc_laser_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_limb_t *playerc_limb_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_limb_destroy(playerc_limb_t *device);
PLAYERC_EXPORT int playerc_limb_subscribe(playerc_limb_t *device, int access);
PLAYERC_EXPORT int playerc_limb_unsubscribe(playerc_limb_t *device);
PLAYERC_EXPORT int playerc_limb_get_geom(playerc_limb_t *device);
PLAYERC_EXPORT int playerc_limb_home_cmd(playerc_limb_t *device);
PLAYERC_EXPORT int playerc_limb_stop_cmd(playerc_limb_t *device);
PLAYERC_EXPORT 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);
PLAYERC_EXPORT int playerc_limb_setposition_cmd(playerc_limb_t *device, float pX, float pY, float pZ);
PLAYERC_EXPORT int playerc_limb_vecmove_cmd(playerc_limb_t *device, float x, float y, float z, float length);
PLAYERC_EXPORT int playerc_limb_power(playerc_limb_t *device, uint32_t enable);
PLAYERC_EXPORT int playerc_limb_brakes(playerc_limb_t *device, uint32_t enable);
PLAYERC_EXPORT 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_EXPORT playerc_localize_t *playerc_localize_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_localize_destroy(playerc_localize_t *device);
PLAYERC_EXPORT int playerc_localize_subscribe(playerc_localize_t *device, int access);
PLAYERC_EXPORT int playerc_localize_unsubscribe(playerc_localize_t *device);
PLAYERC_EXPORT int playerc_localize_set_pose(playerc_localize_t *device, double pose[3], double cov[3]);
PLAYERC_EXPORT int playerc_localize_get_particles(playerc_localize_t *device);
/**************************************************************************/
/***************************************************************************/
typedef struct
{
playerc_device_t info;
int type;
int state;
} playerc_log_t;
PLAYERC_EXPORT playerc_log_t *playerc_log_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_log_destroy(playerc_log_t *device);
PLAYERC_EXPORT int playerc_log_subscribe(playerc_log_t *device, int access);
PLAYERC_EXPORT int playerc_log_unsubscribe(playerc_log_t *device);
PLAYERC_EXPORT int playerc_log_set_write_state(playerc_log_t* device, int state);
PLAYERC_EXPORT int playerc_log_set_read_state(playerc_log_t* device, int state);
PLAYERC_EXPORT int playerc_log_set_read_rewind(playerc_log_t* device);
PLAYERC_EXPORT int playerc_log_get_state(playerc_log_t* device);
PLAYERC_EXPORT 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_EXPORT playerc_map_t *playerc_map_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_map_destroy(playerc_map_t *device);
PLAYERC_EXPORT int playerc_map_subscribe(playerc_map_t *device, int access);
PLAYERC_EXPORT int playerc_map_unsubscribe(playerc_map_t *device);
PLAYERC_EXPORT int playerc_map_get_map(playerc_map_t* device);
PLAYERC_EXPORT 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;
playerwkbprocessor_t wkbprocessor;
} playerc_vectormap_t;
PLAYERC_EXPORT playerc_vectormap_t *playerc_vectormap_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_vectormap_destroy(playerc_vectormap_t *device);
PLAYERC_EXPORT int playerc_vectormap_subscribe(playerc_vectormap_t *device, int access);
PLAYERC_EXPORT int playerc_vectormap_unsubscribe(playerc_vectormap_t *device);
PLAYERC_EXPORT int playerc_vectormap_get_map_info(playerc_vectormap_t* device);
PLAYERC_EXPORT int playerc_vectormap_get_layer_data(playerc_vectormap_t *device, unsigned layer_index);
PLAYERC_EXPORT int playerc_vectormap_write_layer(playerc_vectormap_t *device, const player_vectormap_layer_data_t * data);
PLAYERC_EXPORT void playerc_vectormap_cleanup(playerc_vectormap_t *device);
PLAYERC_EXPORT uint8_t * playerc_vectormap_get_feature_data(playerc_vectormap_t *device, unsigned layer_index, unsigned feature_index);
PLAYERC_EXPORT size_t playerc_vectormap_get_feature_data_count(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_EXPORT playerc_opaque_t *playerc_opaque_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_opaque_destroy(playerc_opaque_t *device);
PLAYERC_EXPORT int playerc_opaque_subscribe(playerc_opaque_t *device, int access);
PLAYERC_EXPORT int playerc_opaque_unsubscribe(playerc_opaque_t *device);
PLAYERC_EXPORT int playerc_opaque_cmd(playerc_opaque_t *device, player_opaque_data_t *data);
PLAYERC_EXPORT 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_EXPORT playerc_planner_t *playerc_planner_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_planner_destroy(playerc_planner_t *device);
PLAYERC_EXPORT int playerc_planner_subscribe(playerc_planner_t *device, int access);
PLAYERC_EXPORT int playerc_planner_unsubscribe(playerc_planner_t *device);
PLAYERC_EXPORT int playerc_planner_set_cmd_pose(playerc_planner_t *device,
double gx, double gy, double ga);
PLAYERC_EXPORT int playerc_planner_get_waypoints(playerc_planner_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_position1d_t *playerc_position1d_create(playerc_client_t *client,
int index);
PLAYERC_EXPORT void playerc_position1d_destroy(playerc_position1d_t *device);
PLAYERC_EXPORT int playerc_position1d_subscribe(playerc_position1d_t *device, int access);
PLAYERC_EXPORT int playerc_position1d_unsubscribe(playerc_position1d_t *device);
PLAYERC_EXPORT int playerc_position1d_enable(playerc_position1d_t *device, int enable);
PLAYERC_EXPORT int playerc_position1d_get_geom(playerc_position1d_t *device);
PLAYERC_EXPORT int playerc_position1d_set_cmd_vel(playerc_position1d_t *device,
double vel, int state);
PLAYERC_EXPORT int playerc_position1d_set_cmd_pos(playerc_position1d_t *device,
double pos, int state);
PLAYERC_EXPORT int playerc_position1d_set_cmd_pos_with_vel(playerc_position1d_t *device,
double pos, double vel, int state);
PLAYERC_EXPORT 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_EXPORT playerc_position2d_t *playerc_position2d_create(playerc_client_t *client,
int index);
PLAYERC_EXPORT void playerc_position2d_destroy(playerc_position2d_t *device);
PLAYERC_EXPORT int playerc_position2d_subscribe(playerc_position2d_t *device, int access);
PLAYERC_EXPORT int playerc_position2d_unsubscribe(playerc_position2d_t *device);
PLAYERC_EXPORT int playerc_position2d_enable(playerc_position2d_t *device, int enable);
PLAYERC_EXPORT int playerc_position2d_get_geom(playerc_position2d_t *device);
PLAYERC_EXPORT int playerc_position2d_set_cmd_vel(playerc_position2d_t *device,
double vx, double vy, double va, int state);
PLAYERC_EXPORT int playerc_position2d_set_cmd_pose_with_vel(playerc_position2d_t *device,
player_pose2d_t pos,
player_pose2d_t vel,
int state);
PLAYERC_EXPORT int playerc_position2d_set_cmd_vel_head(playerc_position2d_t *device,
double vx, double vy, double pa, int state);
PLAYERC_EXPORT int playerc_position2d_set_cmd_pose(playerc_position2d_t *device,
double gx, double gy, double ga, int state);
PLAYERC_EXPORT int playerc_position2d_set_cmd_car(playerc_position2d_t *device,
double vx, double a);
PLAYERC_EXPORT 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_EXPORT playerc_position3d_t *playerc_position3d_create(playerc_client_t *client,
int index);
PLAYERC_EXPORT void playerc_position3d_destroy(playerc_position3d_t *device);
PLAYERC_EXPORT int playerc_position3d_subscribe(playerc_position3d_t *device, int access);
PLAYERC_EXPORT int playerc_position3d_unsubscribe(playerc_position3d_t *device);
PLAYERC_EXPORT int playerc_position3d_enable(playerc_position3d_t *device, int enable);
PLAYERC_EXPORT int playerc_position3d_get_geom(playerc_position3d_t *device);
PLAYERC_EXPORT int playerc_position3d_set_velocity(playerc_position3d_t *device,
double vx, double vy, double vz,
double vr, double vp, double vt,
int state);
PLAYERC_EXPORT int playerc_position3d_set_speed(playerc_position3d_t *device,
double vx, double vy, double vz, int state);
PLAYERC_EXPORT int playerc_position3d_set_pose(playerc_position3d_t *device,
double gx, double gy, double gz,
double gr, double gp, double gt);
PLAYERC_EXPORT int playerc_position3d_set_pose_with_vel(playerc_position3d_t *device,
player_pose3d_t pos,
player_pose3d_t vel);
PLAYERC_EXPORT int playerc_position3d_set_cmd_pose(playerc_position3d_t *device,
double gx, double gy, double gz);
PLAYERC_EXPORT int playerc_position3d_set_vel_mode(playerc_position3d_t *device, int mode);
PLAYERC_EXPORT int playerc_position3d_set_odom(playerc_position3d_t *device,
double ox, double oy, double oz,
double oroll, double opitch, double oyaw);
PLAYERC_EXPORT 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_EXPORT playerc_power_t *playerc_power_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_power_destroy(playerc_power_t *device);
PLAYERC_EXPORT int playerc_power_subscribe(playerc_power_t *device, int access);
PLAYERC_EXPORT 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_EXPORT playerc_ptz_t *playerc_ptz_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_ptz_destroy(playerc_ptz_t *device);
PLAYERC_EXPORT int playerc_ptz_subscribe(playerc_ptz_t *device, int access);
PLAYERC_EXPORT int playerc_ptz_unsubscribe(playerc_ptz_t *device);
PLAYERC_EXPORT int playerc_ptz_set(playerc_ptz_t *device, double pan, double tilt, double zoom);
PLAYERC_EXPORT int playerc_ptz_query_status(playerc_ptz_t *device);
PLAYERC_EXPORT int playerc_ptz_set_ws(playerc_ptz_t *device, double pan, double tilt, double zoom,
double panspeed, double tiltspeed);
PLAYERC_EXPORT int playerc_ptz_set_control_mode(playerc_ptz_t *device, int mode);
/**************************************************************************/
/***************************************************************************/
typedef struct
{
playerc_device_t info;
uint32_t element_count;
double min_angle;
double max_angle;
double angular_res;
double min_range;
double max_range;
double range_res;
double frequency;
player_pose3d_t device_pose;
player_bbox3d_t device_size;
player_pose3d_t *element_poses;
player_bbox3d_t *element_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_EXPORT playerc_ranger_t *playerc_ranger_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_ranger_destroy(playerc_ranger_t *device);
PLAYERC_EXPORT int playerc_ranger_subscribe(playerc_ranger_t *device, int access);
PLAYERC_EXPORT int playerc_ranger_unsubscribe(playerc_ranger_t *device);
PLAYERC_EXPORT int playerc_ranger_get_geom(playerc_ranger_t *device);
PLAYERC_EXPORT int playerc_ranger_power_config(playerc_ranger_t *device, uint8_t value);
PLAYERC_EXPORT int playerc_ranger_intns_config(playerc_ranger_t *device, uint8_t value);
PLAYERC_EXPORT int playerc_ranger_set_config(playerc_ranger_t *device, double min_angle,
double max_angle, double angular_res,
double min_range, double max_range,
double range_res, double frequency);
PLAYERC_EXPORT int playerc_ranger_get_config(playerc_ranger_t *device, double *min_angle,
double *max_angle, double *angular_res,
double *min_range, 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_EXPORT playerc_sonar_t *playerc_sonar_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_sonar_destroy(playerc_sonar_t *device);
PLAYERC_EXPORT int playerc_sonar_subscribe(playerc_sonar_t *device, int access);
PLAYERC_EXPORT int playerc_sonar_unsubscribe(playerc_sonar_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_wifi_t *playerc_wifi_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_wifi_destroy(playerc_wifi_t *device);
PLAYERC_EXPORT int playerc_wifi_subscribe(playerc_wifi_t *device, int access);
PLAYERC_EXPORT int playerc_wifi_unsubscribe(playerc_wifi_t *device);
PLAYERC_EXPORT playerc_wifi_link_t *playerc_wifi_get_link(playerc_wifi_t *device, int link);
/**************************************************************************/
/***************************************************************************/
typedef struct
{
playerc_device_t info;
} playerc_simulation_t;
PLAYERC_EXPORT playerc_simulation_t *playerc_simulation_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_simulation_destroy(playerc_simulation_t *device);
PLAYERC_EXPORT int playerc_simulation_subscribe(playerc_simulation_t *device, int access);
PLAYERC_EXPORT int playerc_simulation_unsubscribe(playerc_simulation_t *device);
PLAYERC_EXPORT int playerc_simulation_set_pose2d(playerc_simulation_t *device, char* name,
double gx, double gy, double ga);
PLAYERC_EXPORT int playerc_simulation_get_pose2d(playerc_simulation_t *device, char* identifier,
double *x, double *y, double *a);
PLAYERC_EXPORT int playerc_simulation_set_pose3d(playerc_simulation_t *device, char* name,
double gx, double gy, double gz,
double groll, double gpitch, double gyaw);
PLAYERC_EXPORT 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);
PLAYERC_EXPORT int playerc_simulation_set_property(playerc_simulation_t *device,
char* name,
char* property,
void* value,
size_t value_len);
PLAYERC_EXPORT int playerc_simulation_get_property(playerc_simulation_t *device,
char* name,
char* property,
void* value,
size_t value_len);
PLAYERC_EXPORT int playerc_simulation_pause(playerc_simulation_t *device );
PLAYERC_EXPORT int playerc_simulation_reset(playerc_simulation_t *device );
PLAYERC_EXPORT int playerc_simulation_save(playerc_simulation_t *device );
/***************************************************************************/
/**************************************************************************/
typedef struct
{
playerc_device_t info;
} playerc_speech_t;
PLAYERC_EXPORT playerc_speech_t *playerc_speech_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_speech_destroy(playerc_speech_t *device);
PLAYERC_EXPORT int playerc_speech_subscribe(playerc_speech_t *device, int access);
PLAYERC_EXPORT int playerc_speech_unsubscribe(playerc_speech_t *device);
PLAYERC_EXPORT 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_EXPORT playerc_speechrecognition_t *playerc_speechrecognition_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_speechrecognition_destroy(playerc_speechrecognition_t *device);
PLAYERC_EXPORT int playerc_speechrecognition_subscribe(playerc_speechrecognition_t *device, int access);
PLAYERC_EXPORT 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_EXPORT playerc_rfid_t *playerc_rfid_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_rfid_destroy(playerc_rfid_t *device);
PLAYERC_EXPORT int playerc_rfid_subscribe(playerc_rfid_t *device, int access);
PLAYERC_EXPORT 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_EXPORT playerc_pointcloud3d_t *playerc_pointcloud3d_create (playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_pointcloud3d_destroy (playerc_pointcloud3d_t *device);
PLAYERC_EXPORT int playerc_pointcloud3d_subscribe (playerc_pointcloud3d_t *device, int access);
PLAYERC_EXPORT int playerc_pointcloud3d_unsubscribe (playerc_pointcloud3d_t *device);
/***************************************************************************/
/**************************************************************************/
typedef player_pointcloud3d_stereo_element_t playerc_pointcloud3d_stereo_element_t;
typedef struct
{
playerc_device_t info;
/* Left channel image */
playerc_camera_t left_channel;
/* Right channel image */
playerc_camera_t right_channel;
/* Disparity image */
playerc_camera_t disparity;
/* 3-D stereo point cloud */
uint32_t points_count;
playerc_pointcloud3d_stereo_element_t *points;
// player_pointcloud3d_data_t pointcloud;
} playerc_stereo_t;
PLAYERC_EXPORT playerc_stereo_t *playerc_stereo_create (playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_stereo_destroy (playerc_stereo_t *device);
PLAYERC_EXPORT int playerc_stereo_subscribe (playerc_stereo_t *device, int access);
PLAYERC_EXPORT int playerc_stereo_unsubscribe (playerc_stereo_t *device);
/***************************************************************************/
/**************************************************************************/
typedef struct
{
playerc_device_t info;
player_pose3d_t pose;
player_pose3d_t vel;
player_pose3d_t acc;
player_imu_data_calib_t calib_data;
float q0, q1, q2, q3;
} playerc_imu_t;
PLAYERC_EXPORT playerc_imu_t *playerc_imu_create (playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_imu_destroy (playerc_imu_t *device);
PLAYERC_EXPORT int playerc_imu_subscribe (playerc_imu_t *device, int access);
PLAYERC_EXPORT int playerc_imu_unsubscribe (playerc_imu_t *device);
PLAYERC_EXPORT int playerc_imu_datatype (playerc_imu_t *device, int value);
PLAYERC_EXPORT 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_EXPORT playerc_wsn_t *playerc_wsn_create(playerc_client_t *client, int index);
PLAYERC_EXPORT void playerc_wsn_destroy(playerc_wsn_t *device);
PLAYERC_EXPORT int playerc_wsn_subscribe(playerc_wsn_t *device, int access);
PLAYERC_EXPORT int playerc_wsn_unsubscribe(playerc_wsn_t *device);
PLAYERC_EXPORT int playerc_wsn_set_devstate(playerc_wsn_t *device, int node_id,
int group_id, int devnr, int state);
PLAYERC_EXPORT int playerc_wsn_power(playerc_wsn_t *device, int node_id, int group_id,
int value);
PLAYERC_EXPORT int playerc_wsn_datatype(playerc_wsn_t *device, int value);
PLAYERC_EXPORT int playerc_wsn_datafreq(playerc_wsn_t *device, int node_id, int group_id,
double frequency);
/***************************************************************************/
#ifdef __cplusplus
}
#endif
#endif
playerc_fiducial_t
Fiducial finder data.
Definition: playerc.h:1510
player_wsn_node_data
Structure describing the WSN node's data packet.
Definition: player_interfaces.h:4335
playerc_opaque_t
Opaque device data.
Definition: playerc.h:2459
playerc_power_t::charge
double charge
Battery charge (Volts).
Definition: playerc.h:2890
playerc_position3d_t::vel_roll
double vel_roll
Angular velocity (radians/sec).
Definition: playerc.h:2797
playerc_wsn_t::node_parent_id
uint32_t node_parent_id
The ID of the WSN node's parent (if existing).
Definition: playerc.h:3620
playerc_ranger_get_geom
PLAYERC_EXPORT int playerc_ranger_get_geom(playerc_ranger_t *device)
Get the ranger geometry.
playerc_map_t::width
int width
Map size, in cells.
Definition: playerc.h:2350
playerc_ranger_t::ranges
double * ranges
Range data [m].
Definition: playerc.h:3057
playerc_planner_t
Planner device data.
Definition: playerc.h:2508
playerc_wsn_datatype
PLAYERC_EXPORT int playerc_wsn_datatype(playerc_wsn_t *device, int value)
Change the data type to RAW or converted engineering units.
playerc_ir_t
Ir proxy data.
Definition: playerc.h:1865
playerc_device_get_boolprop
PLAYERC_EXPORT int playerc_device_get_boolprop(playerc_device_t *device, char *property, BOOL *value)
Request a boolean property.
playerc_rfid_t
RFID proxy data.
Definition: playerc.h:3433
playerc_aio_t
Aio proxy data.
Definition: playerc.h:929
playerc_laser_get_id
PLAYERC_EXPORT int playerc_laser_get_id(playerc_laser_t *device)
Get the laser IDentification information.
playerc_wifi_link_t::mode
int mode
Mode (master, ad-hoc, etc).
Definition: playerc.h:3214
playerc_graphics3d_destroy
PLAYERC_EXPORT void playerc_graphics3d_destroy(playerc_graphics3d_t *device)
Destroy a graphics3d device proxy.
playerc_map_get_map
PLAYERC_EXPORT int playerc_map_get_map(playerc_map_t *device)
Get the map, which is stored in the proxy.
player_opaque_data
data
Definition: player_interfaces.h:3414
playerc_planner_t::gx
double gx
Goal location (m, m, radians)
Definition: playerc.h:2523
playerc_speech_create
PLAYERC_EXPORT playerc_speech_t * playerc_speech_create(playerc_client_t *client, int index)
Create a speech proxy.
playerc_joystick_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1917
playerc_camera_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1398
playerc_audio_sample_load
PLAYERC_EXPORT int playerc_audio_sample_load(playerc_audio_t *device, int index, uint32_t data_count, uint8_t data[], uint32_t format)
Request to load an audio sample.
playerc_dio_subscribe
PLAYERC_EXPORT int playerc_dio_subscribe(playerc_dio_t *device, int access)
Subscribe to the dio device.
playerc_vectormap_t
Vectormap proxy.
Definition: playerc.h:2398
playerc_client_unsubscribe
PLAYERC_EXPORT int playerc_client_unsubscribe(playerc_client_t *client, int code, int index)
Unsubscribe a device.
playerc_gps_t::alt
double alt
Altitude (meters).
Definition: playerc.h:1576
player_blackboard_entry
Vectormap feature data.
Definition: player.h:261
playerc_gps_destroy
PLAYERC_EXPORT void playerc_gps_destroy(playerc_gps_t *device)
Destroy a gps proxy.
playerc_audio_seq_play_cmd
PLAYERC_EXPORT int playerc_audio_seq_play_cmd(playerc_audio_t *device, player_audio_seq_t *tones)
Command to play sequence of tones.
player_bbox3d
A rectangular bounding box, used to define the size of an object.
Definition: player.h:250
player_msghdr
Generic message header.
Definition: player.h:157
player_imu_data_calib
Data: calibrated IMU data (PLAYER_IMU_DATA_CALIB)
Definition: player_interfaces.h:4670
playerc_wsn_t
Note: the structure describing the WSN node's data packet is declared in Player.
Definition: playerc.h:3610
playerc_blackboard_destroy
PLAYERC_EXPORT void playerc_blackboard_destroy(playerc_blackboard_t *device)
Destroy a blackboard proxy.
PLAYER_MAX_DRIVER_STRING_LEN
#define PLAYER_MAX_DRIVER_STRING_LEN
Maximum length for a driver name.
Definition: player.h:68
playerc_client_t
struct _playerc_client_t playerc_client_t
Client object data.
playerc_opaque_unsubscribe
PLAYERC_EXPORT int playerc_opaque_unsubscribe(playerc_opaque_t *device)
Un-subscribe from the opaque device.
playerc_fiducial_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1513
playerc_rfidtag_t
Structure describing a single RFID tag.
Definition: playerc.h:3422
playerc_gripper_t::state
uint8_t state
The gripper's state: may be one of PLAYER_GRIPPER_STATE_OPEN, PLAYER_GRIPPER_STATE_CLOSED, PLAYER_GRIPPER_STATE_MOVING or PLAYER_GRIPPER_STATE_ERROR.
Definition: playerc.h:1763
playerc_camera_t::width
int width
Image dimensions (pixels).
Definition: playerc.h:1401
playerc_localize_t::pending_count
int pending_count
The number of pending (unprocessed) sensor readings.
Definition: playerc.h:2231
playerc_laser_t::scan_count
int scan_count
Number of points in the scan.
Definition: playerc.h:1977
playerc_wifi_link_t
Individual link info.
Definition: playerc.h:3202
player_extent2d
A rectangular bounding box, used to define the origin and bounds of an object.
Definition: player.h:303
playerc_position2d_t::px
double px
Odometric pose (m, m, rad).
Definition: playerc.h:2693
playerc_position3d_reset_odom
PLAYERC_EXPORT int playerc_position3d_reset_odom(playerc_position3d_t *device)
Reset the odometry offset.
playerc_audio_sample_retrieve
PLAYERC_EXPORT int playerc_audio_sample_retrieve(playerc_audio_t *device, int index)
Request to retrieve an audio sample Data is stored in wav_data.
playerc_gps_t::sat_count
int sat_count
Number of satellites in view.
Definition: playerc.h:1594
playerc_log_destroy
PLAYERC_EXPORT void playerc_log_destroy(playerc_log_t *device)
Destroy a log proxy.
playerc_vectormap_t::srid
uint32_t srid
Spatial reference identifier.
Definition: playerc.h:2403
playerc_blackboard_subscribe_to_group
PLAYERC_EXPORT int playerc_blackboard_subscribe_to_group(playerc_blackboard_t *device, const char *group)
Subscribe to a group.
playerc_localize_t
Localization device data.
Definition: playerc.h:2213
playerc_speech_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3351
playerc_camera_t::image_count
int image_count
Size of image data (bytes)
Definition: playerc.h:1418
playerc_laser_t::point
player_point_2d_t * point
Scan data; x, y position (m).
Definition: playerc.h:2001
playerc_graphics2d_clear
PLAYERC_EXPORT int playerc_graphics2d_clear(playerc_graphics2d_t *device)
Clear the canvas.
playerc_log_t::state
int state
Is logging/playback enabled? Call playerc_log_get_state() to fill it.
Definition: playerc.h:2292
playerc_client_delcallback
PLAYERC_EXPORT int playerc_client_delcallback(playerc_client_t *client, struct _playerc_device_t *device, playerc_callback_fn_t callback, void *data)
Remove user callbacks (called when new data arrives).
playerc_graphics3d_clear
PLAYERC_EXPORT int playerc_graphics3d_clear(playerc_graphics3d_t *device)
Clear the canvas.
playerc_position1d_subscribe
PLAYERC_EXPORT int playerc_position1d_subscribe(playerc_position1d_t *device, int access)
Subscribe to the position1d device.
playerc_laser_get_config
PLAYERC_EXPORT 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)
Get the laser configuration.
playerc_vectormap_get_feature_data
PLAYERC_EXPORT uint8_t * playerc_vectormap_get_feature_data(playerc_vectormap_t *device, unsigned layer_index, unsigned feature_index)
Get an individual feature as a WKB geometry.
playerc_actarray_get_actuator_geom
PLAYERC_EXPORT player_actarray_actuatorgeom_t playerc_actarray_get_actuator_geom(playerc_actarray_t *device, uint32_t index)
Accessor method for the actuator geom.
playerc_audio_t::wav_data
player_audio_wav_t wav_data
last block of recorded data
Definition: playerc.h:1089
playerc_power_t::watts
double watts
power currently being used (Watts).
Definition: playerc.h:2900
playerc_graphics3d_rotate
PLAYERC_EXPORT int playerc_graphics3d_rotate(playerc_graphics3d_t *device, double a, double x, double y, double z)
Rotate the drawing coordinate system by [a] radians about the vector described by [x...
playerc_dio_unsubscribe
PLAYERC_EXPORT int playerc_dio_unsubscribe(playerc_dio_t *device)
Un-subscribe from the dio device.
player_color
A color descriptor.
Definition: player.h:316
playerc_gps_t::err_horz
double err_horz
Horizontal and vertical error (meters).
Definition: playerc.h:1588
playerc_pointcloud3d_stereo_element_t
player_pointcloud3d_stereo_element_t playerc_pointcloud3d_stereo_element_t
Structure describing a single 3D pointcloud element.
Definition: playerc.h:3511
playerc_actarray_t::motor_state
uint8_t motor_state
Reports if the actuators are off (0) or on (1)
Definition: playerc.h:999
playerc_device_get_strprop
PLAYERC_EXPORT int playerc_device_get_strprop(playerc_device_t *device, char *property, char **value)
Request a string property.
playerc_laser_get_geom
PLAYERC_EXPORT int playerc_laser_get_geom(playerc_laser_t *device)
Get the laser geometry.
playerc_vectormap_cleanup
PLAYERC_EXPORT void playerc_vectormap_cleanup(playerc_vectormap_t *device)
Clean up the dynamically allocated memory for the vectormap.
playerc_limb_vecmove_cmd
PLAYERC_EXPORT int playerc_limb_vecmove_cmd(playerc_limb_t *device, float x, float y, float z, float length)
Command the end effector to move along the provided vector from its current position for the provided...
playerc_sonar_destroy
PLAYERC_EXPORT void playerc_sonar_destroy(playerc_sonar_t *device)
Destroy a sonar proxy.
playerc_blackboard_unsubscribe_from_key
PLAYERC_EXPORT int playerc_blackboard_unsubscribe_from_key(playerc_blackboard_t *device, const char *key, const char *group)
Unsubscribe from a key.
player_actarray_actuatorgeom
Actuator geometry.
Definition: player_interfaces.h:3786
playerc_position2d_t::vx
double vx
Odometric velocity (m/s, m/s, rad/s).
Definition: playerc.h:2696
playerc_limb_setposition_cmd
PLAYERC_EXPORT int playerc_limb_setposition_cmd(playerc_limb_t *device, float pX, float pY, float pZ)
Command the end effector to move to a specified position (ignoring approach and orientation vectors)...
playerc_ir_subscribe
PLAYERC_EXPORT int playerc_ir_subscribe(playerc_ir_t *device, int access)
Subscribe to the ir device.
playerc_bumper_unsubscribe
PLAYERC_EXPORT int playerc_bumper_unsubscribe(playerc_bumper_t *device)
Un-subscribe from the bumper device.
playerc_audio_sample_play_cmd
PLAYERC_EXPORT int playerc_audio_sample_play_cmd(playerc_audio_t *device, int index)
Command to play prestored sample.
playerc_imu_t::calib_data
player_imu_data_calib_t calib_data
Calibrated IMU data (accel, gyro, magnetometer)
Definition: playerc.h:3570
playerc_simulation_destroy
PLAYERC_EXPORT void playerc_simulation_destroy(playerc_simulation_t *device)
Destroy a simulation proxy.
playerc_pointcloud3d_destroy
PLAYERC_EXPORT void playerc_pointcloud3d_destroy(playerc_pointcloud3d_t *device)
Destroy a pointcloud3d proxy.
playerc_planner_get_waypoints
PLAYERC_EXPORT int playerc_planner_get_waypoints(playerc_planner_t *device)
Get the list of waypoints.
playerc_opaque_destroy
PLAYERC_EXPORT void playerc_opaque_destroy(playerc_opaque_t *device)
Destroy an opaque device proxy.
playerc_limb_setpose_cmd
PLAYERC_EXPORT 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)
Command the end effector to move to a specified pose.
playerc_opaque_create
PLAYERC_EXPORT playerc_opaque_t * playerc_opaque_create(playerc_client_t *client, int index)
Create an opaque device proxy.
playerc_gripper_t::num_beams
uint8_t num_beams
The number of breakbeams the gripper has.
Definition: playerc.h:1756
playerc_speech_destroy
PLAYERC_EXPORT void playerc_speech_destroy(playerc_speech_t *device)
Destroy a speech proxy.
player_health_cpu
Structure describing the cpu.
Definition: player_interfaces.h:4572
playerc_sonar_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3150
playerc_rfid_destroy
PLAYERC_EXPORT void playerc_rfid_destroy(playerc_rfid_t *device)
Destroy a rfid proxy.
playerc_gps_create
PLAYERC_EXPORT playerc_gps_t * playerc_gps_create(playerc_client_t *client, int index)
Create a gps proxy.
player_health_memory
Structure describing the memory.
Definition: player_interfaces.h:4583
playerc_laser_t::intensity_on
int intensity_on
Is intesity data returned.
Definition: playerc.h:1974
playerc_device_t
struct _playerc_device_t playerc_device_t
Common device info.
_playerc_device_t::client
playerc_client_t * client
Pointer to the client proxy.
Definition: playerc.h:822
_playerc_device_t
Common device info.
Definition: playerc.h:814
playerc_audio_get_mixer_levels
PLAYERC_EXPORT int playerc_audio_get_mixer_levels(playerc_audio_t *device)
Request mixer channel data result is stored in mixer_data.
playerc_pointcloud3d_t
pointcloud3d proxy data.
Definition: playerc.h:3474
playerc_position3d_t::pos_x
double pos_x
Device position (m).
Definition: playerc.h:2788
playerc_position2d_subscribe
PLAYERC_EXPORT int playerc_position2d_subscribe(playerc_position2d_t *device, int access)
Subscribe to the position2d device.
playerc_position3d_set_pose
PLAYERC_EXPORT int playerc_position3d_set_pose(playerc_position3d_t *device, double gx, double gy, double gz, double gr, double gp, double gt)
Set the target pose (gx, gy, ga, gr, gp, gt) is the target pose in the odometric coordinate system...
playerc_gps_t::lat
double lat
Latitude and logitude (degrees).
Definition: playerc.h:1572
playerc_graphics3d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1688
playerc_imu_datatype
PLAYERC_EXPORT int playerc_imu_datatype(playerc_imu_t *device, int value)
Change the data type to one of the predefined data structures.
playerc_camera_t
Camera proxy data.
Definition: playerc.h:1395
playerc_laser_subscribe
PLAYERC_EXPORT int playerc_laser_subscribe(playerc_laser_t *device, int access)
Subscribe to the laser device.
playerc_aio_set_output
PLAYERC_EXPORT int playerc_aio_set_output(playerc_aio_t *device, uint8_t id, float volt)
Set the output for the aio device.
playerc_imu_create
PLAYERC_EXPORT playerc_imu_t * playerc_imu_create(playerc_client_t *client, int index)
Create a imu proxy.
playerc_position3d_set_odom
PLAYERC_EXPORT int playerc_position3d_set_odom(playerc_position3d_t *device, double ox, double oy, double oz, double oroll, double opitch, double oyaw)
Set the odometry offset.
playerc_position2d_enable
PLAYERC_EXPORT int playerc_position2d_enable(playerc_position2d_t *device, int enable)
Enable/disable the motors.
playerc_laser_t::scan_start
double scan_start
Start bearing of the scan (radians).
Definition: playerc.h:1980
playerc_gripper_get_geom
PLAYERC_EXPORT int playerc_gripper_get_geom(playerc_gripper_t *device)
Get the gripper geometry.
playerc_simulation_set_property
PLAYERC_EXPORT int playerc_simulation_set_property(playerc_simulation_t *device, char *name, char *property, void *value, size_t value_len)
Set a property value.
playerc_client_adddevice
PLAYERC_EXPORT int playerc_client_adddevice(playerc_client_t *client, struct _playerc_device_t *device)
Add a device proxy.
playerc_planner_t::px
double px
Current pose (m, m, radians).
Definition: playerc.h:2520
playerc_ranger_set_config
PLAYERC_EXPORT int playerc_ranger_set_config(playerc_ranger_t *device, double min_angle, double max_angle, double angular_res, double min_range, double max_range, double range_res, double frequency)
Set the ranger device's configuration.
playerc_planner_t::path_valid
int path_valid
Did the planner find a valid path?
Definition: playerc.h:2514
playerc_stereo_t
stereo proxy data.
Definition: playerc.h:3514
playerc_simulation_t
Simulation device proxy.
Definition: playerc.h:3272
playerc_ptz_set_ws
PLAYERC_EXPORT int playerc_ptz_set_ws(playerc_ptz_t *device, double pan, double tilt, double zoom, double panspeed, double tiltspeed)
Set the pan, tilt and zoom values (and speed)
playerc_speechrecognition_t
Speech recognition proxy data.
Definition: playerc.h:3384
playerc_graphics2d_setcolor
PLAYERC_EXPORT int playerc_graphics2d_setcolor(playerc_graphics2d_t *device, player_color_t col)
Set the current drawing color.
playerc_graphics3d_unsubscribe
PLAYERC_EXPORT int playerc_graphics3d_unsubscribe(playerc_graphics3d_t *device)
Un-subscribe from the graphics3d device.
playerc_ptz_subscribe
PLAYERC_EXPORT int playerc_ptz_subscribe(playerc_ptz_t *device, int access)
Subscribe to the ptz device.
playerc_sonar_t::poses
player_pose3d_t * poses
Pose of each sonar relative to robot (m, m, radians).
Definition: playerc.h:3157
_playerc_client_t::retry_limit
int retry_limit
How many times we'll try to reconnect after a socket error.
Definition: playerc.h:479
playerc_client_internal_peek
PLAYERC_EXPORT int playerc_client_internal_peek(playerc_client_t *client, int timeout)
Test to see if there is pending data.
playerc_limb_destroy
PLAYERC_EXPORT void playerc_limb_destroy(playerc_limb_t *device)
Destroy a limb proxy.
playerc_graphics3d_setcolor
PLAYERC_EXPORT int playerc_graphics3d_setcolor(playerc_graphics3d_t *device, player_color_t col)
Set the current drawing color.
playerc_vectormap_t::layers_count
uint32_t layers_count
The number of layers.
Definition: playerc.h:2407
playerc_ptz_t::pan
double pan
The current ptz pan and tilt angles.
Definition: playerc.h:2945
playerc_device_unsubscribe
PLAYERC_EXPORT int playerc_device_unsubscribe(playerc_device_t *device)
Unsubscribe the device.
playerc_localize_set_pose
PLAYERC_EXPORT int playerc_localize_set_pose(playerc_localize_t *device, double pose[3], double cov[3])
Set the the robot pose (mean and covariance).
playerc_graphics3d_draw
PLAYERC_EXPORT int playerc_graphics3d_draw(playerc_graphics3d_t *device, player_graphics3d_draw_mode_t mode, player_point_3d_t pts[], int count)
Draw some points in the given mode.
playerc_pointcloud3d_t::points_count
uint16_t points_count
The number of 3D pointcloud elementS found.
Definition: playerc.h:3480
playerc_blackboard_unsubscribe
PLAYERC_EXPORT int playerc_blackboard_unsubscribe(playerc_blackboard_t *device)
Un-subscribe from the blackboard device.
playerc_gripper_create
PLAYERC_EXPORT playerc_gripper_t * playerc_gripper_create(playerc_client_t *client, int index)
Create a gripper device proxy.
playerc_actarray_speed_cmd
PLAYERC_EXPORT int playerc_actarray_speed_cmd(playerc_actarray_t *device, int joint, float speed)
Command a joint in the array to move at a specified speed.
playerc_bumper_get_geom
PLAYERC_EXPORT int playerc_bumper_get_geom(playerc_bumper_t *device)
Get the bumper geometry.
playerc_opaque_cmd
PLAYERC_EXPORT int playerc_opaque_cmd(playerc_opaque_t *device, player_opaque_data_t *data)
Send a generic command.
playerc_limb_brakes
PLAYERC_EXPORT int playerc_limb_brakes(playerc_limb_t *device, uint32_t enable)
Turn the brakes of all actuators in the limb that have them on or off.
_playerc_client_t::connected
int connected
Whether or not we're currently connected.
Definition: playerc.h:474
playerc_actarray_multi_position_cmd
PLAYERC_EXPORT int playerc_actarray_multi_position_cmd(playerc_actarray_t *device, float *positions, int positions_count)
Command all joints in the array to move to specified positions.
playerc_device_subscribe
PLAYERC_EXPORT int playerc_device_subscribe(playerc_device_t *device, int access)
Subscribe the device.
playerc_laser_t::scanning_frequency
double scanning_frequency
Scanning frequency in Hz.
Definition: playerc.h:1992
playerc_position3d_create
PLAYERC_EXPORT playerc_position3d_t * playerc_position3d_create(playerc_client_t *client, int index)
Create a position3d device proxy.
playerc_planner_create
PLAYERC_EXPORT playerc_planner_t * playerc_planner_create(playerc_client_t *client, int index)
Create a planner device proxy.
playerc_ranger_t::bearings_count
uint32_t bearings_count
Number of scan bearings.
Definition: playerc.h:3067
player_pose2d
A pose in the plane.
Definition: player.h:213
playerc_blackboard_subscribe
PLAYERC_EXPORT int playerc_blackboard_subscribe(playerc_blackboard_t *device, int access)
Subscribe to the blackboard device.
playerc_client_subscribe
PLAYERC_EXPORT int playerc_client_subscribe(playerc_client_t *client, int code, int index, int access, char *drivername, size_t len)
Subscribe a device.
playerc_ranger_t::intensities
double * intensities
Intensity data [m].
Definition: playerc.h:3064
playerc_bumper_t::bumpers
uint8_t * bumpers
Bump data: unsigned char, either boolean or code indicating corner.
Definition: playerc.h:1355
playerc_laser_t::min_right
double min_right
Minimum range, in meters, in the right half of the scan (those ranges from the first beam...
Definition: playerc.h:2017
playerc_wifi_link_t::freq
double freq
Frequency (MHz).
Definition: playerc.h:3220
playerc_vectormap_write_layer
PLAYERC_EXPORT int playerc_vectormap_write_layer(playerc_vectormap_t *device, const player_vectormap_layer_data_t *data)
Write layer data.
playerc_bumper_destroy
PLAYERC_EXPORT void playerc_bumper_destroy(playerc_bumper_t *device)
Destroy a bumper proxy.
playerc_speech_subscribe
PLAYERC_EXPORT int playerc_speech_subscribe(playerc_speech_t *device, int access)
Subscribe to the speech device.
playerc_fiducial_create
PLAYERC_EXPORT playerc_fiducial_t * playerc_fiducial_create(playerc_client_t *client, int index)
Create a fiducial proxy.
playerc_position3d_get_geom
PLAYERC_EXPORT int playerc_position3d_get_geom(playerc_position3d_t *device)
Get the position3d geometry.
playerc_ranger_t::min_angle
double min_angle
Start angle of scans [rad].
Definition: playerc.h:3028
playerc_position2d_set_cmd_car
PLAYERC_EXPORT int playerc_position2d_set_cmd_car(playerc_position2d_t *device, double vx, double a)
Set the target cmd for car like position.
playerc_ptz_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2940
playerc_graphics2d_t::color
player_color_t color
current drawing color
Definition: playerc.h:1631
playerc_position1d_set_odom
PLAYERC_EXPORT int playerc_position1d_set_odom(playerc_position1d_t *device, double odom)
Set the odometry offset.
playerc_graphics3d_t
Graphics3d device data.
Definition: playerc.h:1685
playerc_health_t::mem
player_health_memory_t mem
The memory stats.
Definition: playerc.h:1831
playerc_gripper_printout
PLAYERC_EXPORT void playerc_gripper_printout(playerc_gripper_t *device, const char *prefix)
Print a human-readable version of the gripper state.
playerc_joystick_subscribe
PLAYERC_EXPORT int playerc_joystick_subscribe(playerc_joystick_t *device, int access)
Subscribe to the joystick device.
playerc_rfid_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3436
playerc_map_create
PLAYERC_EXPORT playerc_map_t * playerc_map_create(playerc_client_t *client, int index)
Create a map proxy.
playerc_opaque_t::data_count
int data_count
Size of data (bytes)
Definition: playerc.h:2465
playerc_blackboard::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1181
playerc_log_t::type
int type
What kind of log device is this? Either PLAYER_LOG_TYPE_READ or PLAYER_LOG_TYPE_WRITE.
Definition: playerc.h:2288
playerc_position1d_t::pos
double pos
Odometric pose [m] or [rad].
Definition: playerc.h:2599
PLAYER_MAX_DEVICES
#define PLAYER_MAX_DEVICES
The maximum number of devices the server will support.
Definition: player.h:70
player_orientation_3d
An angle in 3D space.
Definition: player.h:202
playerc_blobfinder_destroy
PLAYERC_EXPORT void playerc_blobfinder_destroy(playerc_blobfinder_t *device)
Destroy a blobfinder proxy.
playerc_ranger_t::frequency
double frequency
Scanning frequency [Hz].
Definition: playerc.h:3041
playerc_planner_subscribe
PLAYERC_EXPORT int playerc_planner_subscribe(playerc_planner_t *device, int access)
Subscribe to the planner device.
playerc_device_get_dblprop
PLAYERC_EXPORT int playerc_device_get_dblprop(playerc_device_t *device, char *property, double *value)
Request a double property.
playerc_bumper_t::pose_count
int pose_count
Number of pose values.
Definition: playerc.h:1344
playerc_power_t
Power device data.
Definition: playerc.h:2880
playerc_client_disconnect
PLAYERC_EXPORT int playerc_client_disconnect(playerc_client_t *client)
Disconnect from the server.
playerc_blinkenlight_t
Blinklight proxy data.
Definition: playerc.h:1239
playerc_blackboard_subscribe_to_key
PLAYERC_EXPORT int playerc_blackboard_subscribe_to_key(playerc_blackboard_t *device, const char *key, const char *group, player_blackboard_entry_t **entry)
Subscribe to a key.
player_devaddr
A device address.
Definition: player.h:141
playerc_blobfinder_create
PLAYERC_EXPORT playerc_blobfinder_t * playerc_blobfinder_create(playerc_client_t *client, int index)
Create a blobfinder proxy.
playerc_position1d_unsubscribe
PLAYERC_EXPORT int playerc_position1d_unsubscribe(playerc_position1d_t *device)
Un-subscribe from the position1d device.
playerc_position3d_set_velocity
PLAYERC_EXPORT int playerc_position3d_set_velocity(playerc_position3d_t *device, double vx, double vy, double vz, double vr, double vp, double vt, int state)
Set the target speed.
playerc_device_init
PLAYERC_EXPORT void playerc_device_init(playerc_device_t *device, playerc_client_t *client, int code, int index, playerc_putmsg_fn_t putmsg)
Initialise the device.
playerc_graphics2d_draw_polygon
PLAYERC_EXPORT int playerc_graphics2d_draw_polygon(playerc_graphics2d_t *device, player_point_2d_t pts[], int count, int filled, player_color_t fill_color)
Draw a polygon.
playerc_graphics3d_subscribe
PLAYERC_EXPORT int playerc_graphics3d_subscribe(playerc_graphics3d_t *device, int access)
Subscribe to the graphics3d device.
playerc_position1d_t::vel
double vel
Odometric velocity [m/s] or [rad/s].
Definition: playerc.h:2602
playerc_laser_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1962
playerc_position2d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2684
playerc_graphics2d_create
PLAYERC_EXPORT playerc_graphics2d_t * playerc_graphics2d_create(playerc_client_t *client, int index)
Create a graphics2d device proxy.
playerc_map_t::resolution
double resolution
Map resolution, m/cell.
Definition: playerc.h:2347
playerc_blobfinder_subscribe
PLAYERC_EXPORT int playerc_blobfinder_subscribe(playerc_blobfinder_t *device, int access)
Subscribe to the blobfinder device.
playerc_map_get_vector
PLAYERC_EXPORT int playerc_map_get_vector(playerc_map_t *device)
Get the vector map, which is stored in the proxy.
playerc_position2d_set_cmd_vel
PLAYERC_EXPORT int playerc_position2d_set_cmd_vel(playerc_position2d_t *device, double vx, double vy, double va, int state)
Set the target speed.
playerc_planner_destroy
PLAYERC_EXPORT void playerc_planner_destroy(playerc_planner_t *device)
Destroy a planner device proxy.
playerc_power_t::joules
double joules
energy stored (Joules)
Definition: playerc.h:2896
playerc_power_t::valid
int valid
status bits.
Definition: playerc.h:2887
playerc_gps_t::utc_time
double utc_time
UTC time (seconds since the epoch)
Definition: playerc.h:1567
playerc_power_unsubscribe
PLAYERC_EXPORT int playerc_power_unsubscribe(playerc_power_t *device)
Un-subscribe from the power device.
playerc_gripper_t
Gripper device data.
Definition: playerc.h:1741
playerc_localize_t::map_size_x
int map_size_x
Map dimensions (cells).
Definition: playerc.h:2219
playerc_ranger_get_config
PLAYERC_EXPORT int playerc_ranger_get_config(playerc_ranger_t *device, double *min_angle, double *max_angle, double *angular_res, double *min_range, double *max_range, double *range_res, double *frequency)
Get the ranger device's configuration.
playerc_device_set_dblprop
PLAYERC_EXPORT int playerc_device_set_dblprop(playerc_device_t *device, char *property, double value)
Set a double property.
player_limb_data
Data: state (PLAYER_LIMB_DATA)
Definition: player_interfaces.h:4037
player_actarray_actuator
Structure containing a single actuator's information.
Definition: player_interfaces.h:3758
PlayerCc::limit
T limit(T a, T min, T max)
Limit a value to the range of min, max.
Definition: utility.h:114
playerc_map_t
Map proxy data.
Definition: playerc.h:2341
playerc_ranger_t::max_range
double max_range
Maximum range [m].
Definition: playerc.h:3037
playerc_client_peek
PLAYERC_EXPORT int playerc_client_peek(playerc_client_t *client, int timeout)
Wait for response from server (blocking).
playerc_simulation_get_pose3d
PLAYERC_EXPORT 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)
Get the 3D pose of a named simulation object.
playerc_power_t::charging
int charging
charging flag.
Definition: playerc.h:2903
player_limb_geom_req
Request/reply: get geometry.
Definition: player_interfaces.h:4112
playerc_ranger_t::max_angle
double max_angle
End angle of scans [rad].
Definition: playerc.h:3030
playerc_position3d_t
Position3d device data.
Definition: playerc.h:2776
_playerc_device_t::putmsg
playerc_putmsg_fn_t putmsg
Standard message callback for this device.
Definition: playerc.h:854
playerc_device_info_t
Info about an available (but not necessarily subscribed) device.
Definition: playerc.h:448
playerc_blackboard_t
struct playerc_blackboard playerc_blackboard_t
BlackBoard proxy.
playerc_wifi_subscribe
PLAYERC_EXPORT int playerc_wifi_subscribe(playerc_wifi_t *device, int access)
Subscribe to the wifi device.
playerc_wifi_create
PLAYERC_EXPORT playerc_wifi_t * playerc_wifi_create(playerc_client_t *client, int index)
Create a wifi proxy.
playerc_localize_t::hypoth_count
int hypoth_count
List of possible poses.
Definition: playerc.h:2237
playerc_graphics3d_t::color
player_color_t color
current drawing color
Definition: playerc.h:1691
playerc_ranger_t::range_res
double range_res
Range resolution [m].
Definition: playerc.h:3039
playerc_power_subscribe
PLAYERC_EXPORT int playerc_power_subscribe(playerc_power_t *device, int access)
Subscribe to the power device.
playerc_audio_wav_stream_rec_cmd
PLAYERC_EXPORT int playerc_audio_wav_stream_rec_cmd(playerc_audio_t *device, uint8_t state)
Command to set recording state.
playerc_health_destroy
PLAYERC_EXPORT void playerc_health_destroy(playerc_health_t *device)
Destroy a health proxy.
playerc_client_read_nonblock_withproxy
PLAYERC_EXPORT int playerc_client_read_nonblock_withproxy(playerc_client_t *client, void **proxy)
Read and process a packet (nonblocking), fills in pointer to proxy that got data. ...
_playerc_client_t::qitems
playerc_client_item_t qitems[PLAYERC_QUEUE_RING_SIZE]
Definition: playerc.h:514
playerc_ranger_create
PLAYERC_EXPORT playerc_ranger_t * playerc_ranger_create(playerc_client_t *client, int index)
Create a ranger proxy.
_playerc_device_t::freshgeom
int freshgeom
Freshness flag.
Definition: playerc.h:847
playerc_audio_t::seq_data
player_audio_seq_t seq_data
last block of seq data
Definition: playerc.h:1092
playerc_camera_decompress
PLAYERC_EXPORT void playerc_camera_decompress(playerc_camera_t *device)
Decompress the image (modifies the current proxy data).
playerc_sonar_unsubscribe
PLAYERC_EXPORT int playerc_sonar_unsubscribe(playerc_sonar_t *device)
Un-subscribe from the sonar device.
player_vectormap_layer_info
Definition: player_interfaces.h:5102
playerc_device_get_intprop
PLAYERC_EXPORT int playerc_device_get_intprop(playerc_device_t *device, char *property, int32_t *value)
Request an integer property.
player_point_2d
A point in the plane.
Definition: player.h:180
playerc_sonar_create
PLAYERC_EXPORT playerc_sonar_t * playerc_sonar_create(playerc_client_t *client, int index)
Create a sonar proxy.
playerc_audio_t::channel_details_list
player_audio_mixer_channel_list_detail_t channel_details_list
Details of the channels from the mixer.
Definition: playerc.h:1086
playerc_limb_get_geom
PLAYERC_EXPORT int playerc_limb_get_geom(playerc_limb_t *device)
Get the limb geometry.
playerc_limb_unsubscribe
PLAYERC_EXPORT int playerc_limb_unsubscribe(playerc_limb_t *device)
Un-subscribe from the limb device.
_playerc_client_t::host
char * host
Server address.
Definition: playerc.h:467
playerc_ranger_t
Ranger proxy data.
Definition: playerc.h:3019
playerc_localize_t::map_cells
int8_t * map_cells
Map data (empty = -1, unknown = 0, occupied = +1).
Definition: playerc.h:2228
playerc_aio_create
PLAYERC_EXPORT playerc_aio_t * playerc_aio_create(playerc_client_t *client, int index)
Create a aio proxy.
playerc_graphics2d_draw_polyline
PLAYERC_EXPORT int playerc_graphics2d_draw_polyline(playerc_graphics2d_t *device, player_point_2d_t pts[], int count)
Draw a polyline that connects an array of points.
playerc_vectormap_subscribe
PLAYERC_EXPORT int playerc_vectormap_subscribe(playerc_vectormap_t *device, int access)
Subscribe to the vectormap device.
playerc_gripper_store_cmd
PLAYERC_EXPORT int playerc_gripper_store_cmd(playerc_gripper_t *device)
Command the gripper to store.
playerc_imu_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3562
playerc_log_unsubscribe
PLAYERC_EXPORT int playerc_log_unsubscribe(playerc_log_t *device)
Un-subscribe from the log device.
playerc_laser_destroy
PLAYERC_EXPORT void playerc_laser_destroy(playerc_laser_t *device)
Destroy a laser proxy.
playerc_ranger_t::device_pose
player_pose3d_t device_pose
Device geometry in the robot CS: pose gives the position and orientation, size gives the extent...
Definition: playerc.h:3046
playerc_actarray_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:989
playerc_position3d_subscribe
PLAYERC_EXPORT int playerc_position3d_subscribe(playerc_position3d_t *device, int access)
Subscribe to the position3d device.
playerc_rfidtag_t::guid
uint8_t * guid
The Globally Unique IDentifier (GUID) of the tag.
Definition: playerc.h:3429
playerc_wifi_get_link
PLAYERC_EXPORT playerc_wifi_link_t * playerc_wifi_get_link(playerc_wifi_t *device, int link)
Get link state.
_playerc_client_t::devinfos
playerc_device_info_t devinfos[PLAYER_MAX_DEVICES]
List of available (but not necessarily subscribed) devices.
Definition: playerc.h:506
playerc_graphics2d_destroy
PLAYERC_EXPORT void playerc_graphics2d_destroy(playerc_graphics2d_t *device)
Destroy a graphics2d device proxy.
playerc_localize_t::map_scale
double map_scale
Map scale (m/cell).
Definition: playerc.h:2222
playerc_vectormap_t::layers_info
player_vectormap_layer_info_t ** layers_info
Layer info.
Definition: playerc.h:2411
playerc_ptz_query_status
PLAYERC_EXPORT int playerc_ptz_query_status(playerc_ptz_t *device)
Query the pan and tilt status.
playerc_actarray_position_cmd
PLAYERC_EXPORT int playerc_actarray_position_cmd(playerc_actarray_t *device, int joint, float position)
Command a joint in the array to move to a specified position.
_playerc_device_t::lasttime
double lasttime
Data timestamp from the previous data.
Definition: playerc.h:838
playerc_device_set_boolprop
PLAYERC_EXPORT int playerc_device_set_boolprop(playerc_device_t *device, char *property, BOOL value)
Set a boolean property.
playerc_blinkenlight_color
PLAYERC_EXPORT int playerc_blinkenlight_color(playerc_blinkenlight_t *device, uint32_t id, uint8_t red, uint8_t green, uint8_t blue)
Set the output color for the blinkenlight device.
playerc_gps_t::quality
int quality
Quality of fix 0 = invalid, 1 = GPS fix, 2 = DGPS fix.
Definition: playerc.h:1591
playerc_audio_get_mixer_details
PLAYERC_EXPORT int playerc_audio_get_mixer_details(playerc_audio_t *device)
Request mixer channel details list result is stored in channel_details_list.
playerc_device_set_strprop
PLAYERC_EXPORT int playerc_device_set_strprop(playerc_device_t *device, char *property, char *value)
Set a string property.
playerc_simulation_set_pose3d
PLAYERC_EXPORT int playerc_simulation_set_pose3d(playerc_simulation_t *device, char *name, double gx, double gy, double gz, double groll, double gpitch, double gyaw)
Set the 3D pose of a named simulation object.
playerc_wsn_unsubscribe
PLAYERC_EXPORT int playerc_wsn_unsubscribe(playerc_wsn_t *device)
Un-subscribe from the wsn device.
playerc_map_t::vminx
double vminx
Vector-based version of the map (call playerc_map_get_vector() to fill this in).
Definition: playerc.h:2360
playerc_laser_t::max_range
double max_range
Maximum range of sensor, in m.
Definition: playerc.h:1989
playerc_position3d_set_speed
PLAYERC_EXPORT int playerc_position3d_set_speed(playerc_position3d_t *device, double vx, double vy, double vz, int state)
For compatibility with old position3d interface.
playerc_camera_destroy
PLAYERC_EXPORT void playerc_camera_destroy(playerc_camera_t *device)
Destroy a camera proxy.
playerc_blackboard_set_entry
PLAYERC_EXPORT int playerc_blackboard_set_entry(playerc_blackboard_t *device, player_blackboard_entry_t *entry)
Set an entry value.
playerc_gripper_t::capacity
uint8_t capacity
The capacity of the gripper's store - if 0, the gripper cannot store.
Definition: playerc.h:1758
playerc_pointcloud3d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3477
playerc_speech_say
PLAYERC_EXPORT int playerc_speech_say(playerc_speech_t *device, char *)
Set the output for the speech device.
player_ir_data
Data: ranges (PLAYER_IR_DATA_RANGES)
Definition: player_interfaces.h:2113
playerc_error_str
PLAYERC_EXPORT const char * playerc_error_str(void)
Retrieve the last error (as a descriptive string).
_playerc_device_t::datatime
double datatime
Data timestamp, i.e., the time at which the data was generated (s).
Definition: playerc.h:835
playerc_map_destroy
PLAYERC_EXPORT void playerc_map_destroy(playerc_map_t *device)
Destroy a map proxy.
playerc_blinkenlight_create
PLAYERC_EXPORT playerc_blinkenlight_t * playerc_blinkenlight_create(playerc_client_t *client, int index)
Create a blinkenlight proxy.
playerc_graphics3d_translate
PLAYERC_EXPORT int playerc_graphics3d_translate(playerc_graphics3d_t *device, double x, double y, double z)
Translate the drawing coordinate system in 3d.
playerc_aio_get_data
PLAYERC_EXPORT float playerc_aio_get_data(playerc_aio_t *device, uint32_t index)
get the aio data
playerc_vectormap_get_layer_data
PLAYERC_EXPORT int playerc_vectormap_get_layer_data(playerc_vectormap_t *device, unsigned layer_index)
Get the layer data by index.
playerc_ptz_t
PTZ device data.
Definition: playerc.h:2937
playerc_position1d_get_geom
PLAYERC_EXPORT int playerc_position1d_get_geom(playerc_position1d_t *device)
Get the position1d geometry.
playerc_speechrecognition_unsubscribe
PLAYERC_EXPORT int playerc_speechrecognition_unsubscribe(playerc_speechrecognition_t *device)
Un-subscribe from the speech recognition device.
playerc_limb_speed_config
PLAYERC_EXPORT int playerc_limb_speed_config(playerc_limb_t *device, float speed)
Set the speed of the end effector (m/s) for all subsequent movement commands.
playerc_bumper_t::bumper_count
int bumper_count
Number of points in the scan.
Definition: playerc.h:1352
playerc_ir_unsubscribe
PLAYERC_EXPORT int playerc_ir_unsubscribe(playerc_ir_t *device)
Un-subscribe from the ir device.
playerc_imu_unsubscribe
PLAYERC_EXPORT int playerc_imu_unsubscribe(playerc_imu_t *device)
Un-subscribe from the imu device.
_playerc_device_t::id
void * id
A useful ID for identifying devices; mostly used by other language bindings.
Definition: playerc.h:819
playerc_position2d_t::stall
int stall
Stall flag [0, 1].
Definition: playerc.h:2699
playerc_ranger_destroy
PLAYERC_EXPORT void playerc_ranger_destroy(playerc_ranger_t *device)
Destroy a ranger proxy.
playerc_blinkenlight_subscribe
PLAYERC_EXPORT int playerc_blinkenlight_subscribe(playerc_blinkenlight_t *device, int access)
Subscribe to the blinkenlight device.
_playerc_client_t::overflow_count
uint32_t overflow_count
How many messages were lost on the server due to overflows, incremented by player, cleared by user.
Definition: playerc.h:486
playerc_wifi_destroy
PLAYERC_EXPORT void playerc_wifi_destroy(playerc_wifi_t *device)
Destroy a wifi proxy.
playerc_ptz_unsubscribe
PLAYERC_EXPORT int playerc_ptz_unsubscribe(playerc_ptz_t *device)
Un-subscribe from the ptz device.
player_audio_seq
Player audio sequence.
Definition: player_interfaces.h:1502
playerc_localize_particle
Hypothesis data.
Definition: playerc.h:2205
playerc_vectormap_create
PLAYERC_EXPORT playerc_vectormap_t * playerc_vectormap_create(playerc_client_t *client, int index)
Create a vectormap proxy.
playerc_fiducial_unsubscribe
PLAYERC_EXPORT int playerc_fiducial_unsubscribe(playerc_fiducial_t *device)
Un-subscribe from the fiducial device.
playerc_gps_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1564
playerc_position3d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2779
playerc_actarray_get_geom
PLAYERC_EXPORT int playerc_actarray_get_geom(playerc_actarray_t *device)
Get the actarray geometry.
playerc_ptz_set_control_mode
PLAYERC_EXPORT int playerc_ptz_set_control_mode(playerc_ptz_t *device, int mode)
Change control mode (select velocity or position control)
playerc_laser_t::scan_res
double scan_res
Angular resolution in radians.
Definition: playerc.h:1983
playerc_wsn_set_devstate
PLAYERC_EXPORT int playerc_wsn_set_devstate(playerc_wsn_t *device, int node_id, int group_id, int devnr, int state)
Set the device state.
playerc_planner_t::path_done
int path_done
Have we arrived at the goal?
Definition: playerc.h:2517
playerc_client_deldevice
PLAYERC_EXPORT int playerc_client_deldevice(playerc_client_t *client, struct _playerc_device_t *device)
Remove a device proxy.
playerc_ranger_t::angular_res
double angular_res
Scan resolution [rad].
Definition: playerc.h:3032
playerc_imu_reset_orientation
PLAYERC_EXPORT int playerc_imu_reset_orientation(playerc_imu_t *device, int value)
Reset orientation.
playerc_dio_create
PLAYERC_EXPORT playerc_dio_t * playerc_dio_create(playerc_client_t *client, int index)
Create a dio proxy.
playerc_simulation_save
PLAYERC_EXPORT int playerc_simulation_save(playerc_simulation_t *device)
make the simulation save the status/world
playerc_position2d_set_odom
PLAYERC_EXPORT int playerc_position2d_set_odom(playerc_position2d_t *device, double ox, double oy, double oa)
Set the odometry offset.
playerc_wsn_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3613
playerc_camera_save
PLAYERC_EXPORT void playerc_camera_save(playerc_camera_t *device, const char *filename)
Saves the image to disk as a .ppm.
playerc_actarray_speed_config
PLAYERC_EXPORT int playerc_actarray_speed_config(playerc_actarray_t *device, int joint, float speed)
Set the speed of a joint (-1 for all joints) for all subsequent movement commands.
playerc_laser_t::ranges
double * ranges
Raw range data; range (m).
Definition: playerc.h:1995
playerc_laser_t::range_res
double range_res
Range resolution, in m.
Definition: playerc.h:1986
playerc_speech_t
Speech proxy data.
Definition: playerc.h:3348
playerc_position2d_destroy
PLAYERC_EXPORT void playerc_position2d_destroy(playerc_position2d_t *device)
Destroy a position2d device proxy.
playerc_position1d_t
Position1d device data.
Definition: playerc.h:2587
playerc_actarray_t::actuators_count
uint32_t actuators_count
The number of actuators in the array.
Definition: playerc.h:992
playerc_position2d_set_cmd_vel_head
PLAYERC_EXPORT int playerc_position2d_set_cmd_vel_head(playerc_position2d_t *device, double vx, double vy, double pa, int state)
Set the target speed and heading.
playerc_simulation_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3275
playerc_position2d_unsubscribe
PLAYERC_EXPORT int playerc_position2d_unsubscribe(playerc_position2d_t *device)
Un-subscribe from the position2d device.
playerc_position1d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2590
playerc_log_get_state
PLAYERC_EXPORT int playerc_log_get_state(playerc_log_t *device)
Get logging/playback state.
playerc_client_write
PLAYERC_EXPORT int playerc_client_write(playerc_client_t *client, struct _playerc_device_t *device, uint8_t subtype, void *cmd, double *timestamp)
Write data to the server.
playerc_laser_unsubscribe
PLAYERC_EXPORT int playerc_laser_unsubscribe(playerc_laser_t *device)
Un-subscribe from the laser device.
playerc_camera_unsubscribe
PLAYERC_EXPORT int playerc_camera_unsubscribe(playerc_camera_t *device)
Un-subscribe from the camera device.
playerc_opaque_subscribe
PLAYERC_EXPORT int playerc_opaque_subscribe(playerc_opaque_t *device, int access)
Subscribe to the opaque device.
playerc_graphics2d_draw_points
PLAYERC_EXPORT int playerc_graphics2d_draw_points(playerc_graphics2d_t *device, player_point_2d_t pts[], int count)
Draw some points.
_playerc_client_t::data
char * data
Definition: playerc.h:518
playerc_audio_wav_play_cmd
PLAYERC_EXPORT int playerc_audio_wav_play_cmd(playerc_audio_t *device, uint32_t data_count, uint8_t data[], uint32_t format)
Command to play an audio block.
playerc_device_term
PLAYERC_EXPORT void playerc_device_term(playerc_device_t *device)
Finalize the device.
playerc_localize_unsubscribe
PLAYERC_EXPORT int playerc_localize_unsubscribe(playerc_localize_t *device)
Un-subscribe from the localize device.
playerc_gps_t::utm_e
double utm_e
UTM easting and northing (meters).
Definition: playerc.h:1579
playerc_log_set_read_rewind
PLAYERC_EXPORT int playerc_log_set_read_rewind(playerc_log_t *device)
Rewind playback.
playerc_health_subscribe
PLAYERC_EXPORT int playerc_health_subscribe(playerc_health_t *device, int access)
Subscribe to the health device.
playerc_laser_t::scan_id
int scan_id
ID for this scan.
Definition: playerc.h:2009
playerc_client_set_replace_rule
PLAYERC_EXPORT int playerc_client_set_replace_rule(playerc_client_t *client, int interf, int index, int type, int subtype, int replace)
Set a replace rule for the client queue on the server.
playerc_gps_t
GPS proxy data.
Definition: playerc.h:1561
playerc_wsn_datafreq
PLAYERC_EXPORT int playerc_wsn_datafreq(playerc_wsn_t *device, int node_id, int group_id, double frequency)
Change data delivery frequency.
playerc_gripper_t::beams
uint32_t beams
The position of the object in the gripper.
Definition: playerc.h:1765
playerc_gripper_destroy
PLAYERC_EXPORT void playerc_gripper_destroy(playerc_gripper_t *device)
Destroy a gripper device proxy.
playerc_client_set_request_timeout
PLAYERC_EXPORT void playerc_client_set_request_timeout(playerc_client_t *client, uint32_t seconds)
Set the timeout for client requests.
playerc_audio_t
Audio device data.
Definition: playerc.h:1080
playerc_gripper_t::pose
player_pose3d_t pose
Gripper geometry in the robot cs: pose gives the position and orientation, outer_size gives the exten...
Definition: playerc.h:1752
playerc_map_unsubscribe
PLAYERC_EXPORT int playerc_map_unsubscribe(playerc_map_t *device)
Un-subscribe from the map device.
playerc_ir_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1868
playerc_log_set_read_state
PLAYERC_EXPORT int playerc_log_set_read_state(playerc_log_t *device, int state)
Start/stop playback.
playerc_health_unsubscribe
PLAYERC_EXPORT int playerc_health_unsubscribe(playerc_health_t *device)
Un-subscribe from the health device.
playerc_wifi_link_t::qual
int qual
Link properties.
Definition: playerc.h:3223
playerc_health_create
PLAYERC_EXPORT playerc_health_t * playerc_health_create(playerc_client_t *client, int index)
Create a health proxy.
playerc_imu_t::pose
player_pose3d_t pose
The complete pose of the IMU in 3D coordinates + angles.
Definition: playerc.h:3565
playerc_position3d_set_vel_mode
PLAYERC_EXPORT int playerc_position3d_set_vel_mode(playerc_position3d_t *device, int mode)
Set the velocity mode.
playerc_actarray_multi_current_cmd
PLAYERC_EXPORT int playerc_actarray_multi_current_cmd(playerc_actarray_t *device, float *currents, int currents_count)
Command all joints in the array to move with specified currents.
playerc_sonar_t
Sonar proxy data.
Definition: playerc.h:3147
playerc_health_t
Note: the structure describing the HEALTH's data packet is declared in Player.
Definition: playerc.h:1824
playerc_graphics2d_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1628
playerc_ranger_t::element_count
uint32_t element_count
Number of individual elements in the device.
Definition: playerc.h:3025
playerc_localize_subscribe
PLAYERC_EXPORT int playerc_localize_subscribe(playerc_localize_t *device, int access)
Subscribe to the localize device.
playerc_blackboard_create
PLAYERC_EXPORT playerc_blackboard_t * playerc_blackboard_create(playerc_client_t *client, int index)
Create a blackboard proxy.
playerc_gripper_subscribe
PLAYERC_EXPORT int playerc_gripper_subscribe(playerc_gripper_t *device, int access)
Subscribe to the gripper device.
playerc_ptz_t::zoom
double zoom
The current zoom value (field of view angle).
Definition: playerc.h:2948
playerc_joystick_unsubscribe
PLAYERC_EXPORT int playerc_joystick_unsubscribe(playerc_joystick_t *device)
Un-subscribe from the joystick device.
playerc_power_create
PLAYERC_EXPORT playerc_power_t * playerc_power_create(playerc_client_t *client, int index)
Create a power device proxy.
playerc_gripper_t::stored
uint8_t stored
The number of currently-stored objects.
Definition: playerc.h:1767
_playerc_client_t::mode
uint8_t mode
Definition: playerc.h:493
playerc_blobfinder_t::blobs_count
unsigned int blobs_count
A list of detected blobs.
Definition: playerc.h:1304
playerc_rfid_t::tags
playerc_rfidtag_t * tags
The list of RFID tags.
Definition: playerc.h:3442
playerc_stereo_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3517
playerc_limb_power
PLAYERC_EXPORT int playerc_limb_power(playerc_limb_t *device, uint32_t enable)
Turn the power to the limb on or off.
playerc_pointcloud3d_element_t
player_pointcloud3d_element_t playerc_pointcloud3d_element_t
Structure describing a single 3D pointcloud element.
Definition: playerc.h:3471
playerc_ranger_subscribe
PLAYERC_EXPORT int playerc_ranger_subscribe(playerc_ranger_t *device, int access)
Subscribe to the ranger device.
playerc_dio_set_output
PLAYERC_EXPORT int playerc_dio_set_output(playerc_dio_t *device, uint8_t output_count, uint32_t digout)
Set the output for the dio device.
_playerc_device_t::freshconfig
int freshconfig
Freshness flag.
Definition: playerc.h:851
playerc_ranger_t::intensities_count
uint32_t intensities_count
Number of intensities in a scan.
Definition: playerc.h:3060
playerc_camera_subscribe
PLAYERC_EXPORT int playerc_camera_subscribe(playerc_camera_t *device, int access)
Subscribe to the camera device.
playerc_limb_stop_cmd
PLAYERC_EXPORT int playerc_limb_stop_cmd(playerc_limb_t *device)
Command the end effector to stop immediatly.
playerc_actarray_get_actuator_data
PLAYERC_EXPORT player_actarray_actuator_t playerc_actarray_get_actuator_data(playerc_actarray_t *device, uint32_t index)
Accessor method for the actuator data.
playerc_gps_unsubscribe
PLAYERC_EXPORT int playerc_gps_unsubscribe(playerc_gps_t *device)
Un-subscribe from the gps device.
playerc_position2d_set_cmd_pose_with_vel
PLAYERC_EXPORT int playerc_position2d_set_cmd_pose_with_vel(playerc_position2d_t *device, player_pose2d_t pos, player_pose2d_t vel, int state)
Set the target pose with given motion vel.
playerc_joystick_destroy
PLAYERC_EXPORT void playerc_joystick_destroy(playerc_joystick_t *device)
Destroy a joystick proxy.
playerc_graphics2d_unsubscribe
PLAYERC_EXPORT int playerc_graphics2d_unsubscribe(playerc_graphics2d_t *device)
Un-subscribe from the graphics2d device.
playerc_fiducial_t::fiducial_geom
player_fiducial_geom_t fiducial_geom
Geometry in robot cs.
Definition: playerc.h:1519
playerc_wsn_create
PLAYERC_EXPORT playerc_wsn_t * playerc_wsn_create(playerc_client_t *client, int index)
Create a wsn proxy.
playerc_gripper_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1744
player_vectormap_layer_data
Vectormap data.
Definition: player_interfaces.h:5113
playerc_blobfinder_t
Blobfinder device data.
Definition: playerc.h:1295
playerc_planner_t::curr_waypoint
int curr_waypoint
Current waypoint index (handy if you already have the list of waypoints).
Definition: playerc.h:2531
playerc_pointcloud3d_subscribe
PLAYERC_EXPORT int playerc_pointcloud3d_subscribe(playerc_pointcloud3d_t *device, int access)
Subscribe to the pointcloud3d device.
playerc_speechrecognition_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3387
playerc_map_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2344
playerc_localize_get_particles
PLAYERC_EXPORT int playerc_localize_get_particles(playerc_localize_t *device)
Request the particle set.
playerc_device_hascapability
PLAYERC_EXPORT int playerc_device_hascapability(playerc_device_t *device, uint32_t type, uint32_t subtype)
Request capabilities of device.
playerc_joystick_create
PLAYERC_EXPORT playerc_joystick_t * playerc_joystick_create(playerc_client_t *client, int index)
Create a joystick proxy.
playerc_blinkenlight_unsubscribe
PLAYERC_EXPORT int playerc_blinkenlight_unsubscribe(playerc_blinkenlight_t *device)
Un-subscribe from the blinkenlight device.
playerc_ptz_t::status
int status
The current pan and tilt status.
Definition: playerc.h:2951
_playerc_device_t::fresh
int fresh
Freshness flag.
Definition: playerc.h:843
playerc_health_t::swap
player_health_memory_t swap
The swap stats.
Definition: playerc.h:1833
playerc_blinkenlight_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1242
playerc_opaque_req
PLAYERC_EXPORT int playerc_opaque_req(playerc_opaque_t *device, player_opaque_data_t *request, player_opaque_data_t **reply)
Send a generic request.
playerc_audio_destroy
PLAYERC_EXPORT void playerc_audio_destroy(playerc_audio_t *device)
Destroy an audio proxy.
playerc_bumper_create
PLAYERC_EXPORT playerc_bumper_t * playerc_bumper_create(playerc_client_t *client, int index)
Create a bumper proxy.
playerc_laser_create
PLAYERC_EXPORT playerc_laser_t * playerc_laser_create(playerc_client_t *client, int index)
Create a laser proxy.
playerc_laser_t::min_left
double min_left
Minimum range, in meters, in the left half of the scan (those ranges from the first beam after the mi...
Definition: playerc.h:2022
playerc_graphics2d_t
Graphics2d device data.
Definition: playerc.h:1625
playerc_fiducial_t::fiducials_count
int fiducials_count
List of detected beacons.
Definition: playerc.h:1522
playerc_ranger_t::ranges_count
uint32_t ranges_count
Number of ranges in a scan.
Definition: playerc.h:3055
playerc_pointcloud3d_unsubscribe
PLAYERC_EXPORT int playerc_pointcloud3d_unsubscribe(playerc_pointcloud3d_t *device)
Un-subscribe from the pointcloud3d device.
playerc_health_t::cpu_usage
player_health_cpu_t cpu_usage
The current cpu usage.
Definition: playerc.h:1829
playerc_health_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1827
playerc_ranger_t::points
player_point_3d_t * points
Scan points (x, y, z).
Definition: playerc.h:3075
playerc_rfidtag_t::type
uint32_t type
Tag type.
Definition: playerc.h:3425
playerc_dio_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1464
playerc_wifi_t::links
playerc_wifi_link_t * links
A list containing info for each link.
Definition: playerc.h:3235
playerc_sonar_t::scan
double * scan
Scan data: range (m).
Definition: playerc.h:3163
playerc_position3d_set_cmd_pose
PLAYERC_EXPORT int playerc_position3d_set_cmd_pose(playerc_position3d_t *device, double gx, double gy, double gz)
For compatibility with old position3d interface.
playerc_fiducial_subscribe
PLAYERC_EXPORT int playerc_fiducial_subscribe(playerc_fiducial_t *device, int access)
Subscribe to the fiducial device.
playerc_stereo_subscribe
PLAYERC_EXPORT int playerc_stereo_subscribe(playerc_stereo_t *device, int access)
Subscribe to the stereo device.
playerc_log_set_write_state
PLAYERC_EXPORT int playerc_log_set_write_state(playerc_log_t *device, int state)
Start/stop logging.
playerc_actarray_multi_speed_cmd
PLAYERC_EXPORT int playerc_actarray_multi_speed_cmd(playerc_actarray_t *device, float *speeds, int speeds_count)
Command a joint in the array to move at a specified speed.
playerc_localize_destroy
PLAYERC_EXPORT void playerc_localize_destroy(playerc_localize_t *device)
Destroy a localize proxy.
playerc_actarray_create
PLAYERC_EXPORT playerc_actarray_t * playerc_actarray_create(playerc_client_t *client, int index)
Create an actarray proxy.
playerc_client_requestdata
PLAYERC_EXPORT int playerc_client_requestdata(playerc_client_t *client)
Request a round of data.
playerc_rfidtag_t::guid_count
uint32_t guid_count
GUID count.
Definition: playerc.h:3427
playerc_simulation_get_property
PLAYERC_EXPORT int playerc_simulation_get_property(playerc_simulation_t *device, char *name, char *property, void *value, size_t value_len)
Get a property value.
playerc_camera_t::bpp
int bpp
Image bits-per-pixel (8, 16, 24).
Definition: playerc.h:1404
playerc_wsn_destroy
PLAYERC_EXPORT void playerc_wsn_destroy(playerc_wsn_t *device)
Destroy a wsn proxy.
playerc_client_create
PLAYERC_EXPORT playerc_client_t * playerc_client_create(playerc_mclient_t *mclient, const char *host, int port)
Create a client object.
playerc_bumper_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1341
playerc_client_set_retry_limit
PLAYERC_EXPORT void playerc_client_set_retry_limit(playerc_client_t *client, int limit)
Set the connection retry limit.
playerc_rfid_create
PLAYERC_EXPORT playerc_rfid_t * playerc_rfid_create(playerc_client_t *client, int index)
Create a rfid proxy.
playerc_position1d_enable
PLAYERC_EXPORT int playerc_position1d_enable(playerc_position1d_t *device, int enable)
Enable/disable the motors.
playerc_wifi_link_t::encrypt
int encrypt
Encrypted?
Definition: playerc.h:3217
playerc_bumper_t
Bumper proxy data.
Definition: playerc.h:1338
playerc_log_t
Log proxy data.
Definition: playerc.h:2281
_playerc_client_t::sock
int sock
Definition: playerc.h:490
playerc_client_request
PLAYERC_EXPORT int playerc_client_request(playerc_client_t *client, struct _playerc_device_t *device, uint8_t reqtype, const void *req_data, void **rep_data)
Issue a request to the server and await a reply (blocking).
playerc_gps_t::hdop
double hdop
Horizontal dilution of precision.
Definition: playerc.h:1582
playerc_blinkenlight_enable
PLAYERC_EXPORT int playerc_blinkenlight_enable(playerc_blinkenlight_t *device, uint32_t enable)
Enable/disable power to the blinkenlight device.
playerc_client_destroy
PLAYERC_EXPORT void playerc_client_destroy(playerc_client_t *client)
Destroy a client object.
playerc_imu_t::q0
float q0
Orientation data as quaternions.
Definition: playerc.h:3573
playerc_laser_t::laser_id
int laser_id
Laser IDentification information.
Definition: playerc.h:2012
player_ir_pose
Request/reply: get pose.
Definition: player_interfaces.h:2128
playerc_dio_destroy
PLAYERC_EXPORT void playerc_dio_destroy(playerc_dio_t *device)
Destroy a dio proxy.
playerc_bumper_subscribe
PLAYERC_EXPORT int playerc_bumper_subscribe(playerc_bumper_t *device, int access)
Subscribe to the bumper device.
playerc_simulation_get_pose2d
PLAYERC_EXPORT int playerc_simulation_get_pose2d(playerc_simulation_t *device, char *identifier, double *x, double *y, double *a)
Get the 2D pose of a named simulation object.
playerc_client_datamode
PLAYERC_EXPORT int playerc_client_datamode(playerc_client_t *client, uint8_t mode)
Change the server's data delivery mode.
playerc_putmsg_fn_t
PLAYERC_EXPORT typedef void(* playerc_putmsg_fn_t)(void *device, char *header, char *data)
Typedef for proxy callback function.
Definition: playerc.h:439
playerc_vectormap_t::wkbprocessor
playerwkbprocessor_t wkbprocessor
WKB processor instance if you want to deal with WKB data.
Definition: playerc.h:2413
playerc_planner_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2511
playerc_ptz_destroy
PLAYERC_EXPORT void playerc_ptz_destroy(playerc_ptz_t *device)
Destroy a ptz proxy.
player_blobfinder_blob
Structure describing a single blob.
Definition: player_interfaces.h:1071
_playerc_device_t::callback_count
int callback_count
Extra callbacks for this device.
Definition: playerc.h:860
playerc_position1d_destroy
PLAYERC_EXPORT void playerc_position1d_destroy(playerc_position1d_t *device)
Destroy a position1d device proxy.
_playerc_client_t::datatime
double datatime
Server time stamp on the last packet.
Definition: playerc.h:525
playerc_power_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2883
_playerc_client_t
Client object data.
Definition: playerc.h:460
playerc_camera_t::compression
int compression
Image compression method.
Definition: playerc.h:1415
playerc_log_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2284
playerc_position2d_set_cmd_pose
PLAYERC_EXPORT int playerc_position2d_set_cmd_pose(playerc_position2d_t *device, double gx, double gy, double ga, int state)
Set the target pose (gx, gy, ga) is the target pose in the odometric coordinate system.
player_pointcloud3d_element
3D Pointcloud element structure An element as stored in a 3D pointcloud, containing a 3D position plu...
Definition: player_interfaces.h:4798
playerc_position3d_destroy
PLAYERC_EXPORT void playerc_position3d_destroy(playerc_position3d_t *device)
Destroy a position3d device proxy.
playerc_position2d_t
Position2d device data.
Definition: playerc.h:2681
playerc_position1d_create
PLAYERC_EXPORT playerc_position1d_t * playerc_position1d_create(playerc_client_t *client, int index)
Create a position1d device proxy.
playerc_laser_t
Laser proxy data.
Definition: playerc.h:1959
playerc_ir_destroy
PLAYERC_EXPORT void playerc_ir_destroy(playerc_ir_t *device)
Destroy a ir proxy.
playerc_opaque_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2462
playerc_camera_t::image
uint8_t * image
Image data (byte aligned, row major order).
Definition: playerc.h:1424
playerc_joystick_t
joystick proxy data.
Definition: playerc.h:1914
playerc_localize_t::map_tile_x
int map_tile_x
Next map tile to read.
Definition: playerc.h:2225
playerc_add_xdr_ftable
PLAYERC_EXPORT int playerc_add_xdr_ftable(playerxdr_function_t *flist, int replace)
Get the name for a given interface code.
_playerc_client_t::data_requested
int data_requested
Definition: playerc.h:497
playerc_sonar_t::scan_count
int scan_count
Number of points in the scan.
Definition: playerc.h:3160
playerc_position3d_t::pos_roll
double pos_roll
Device orientation (radians).
Definition: playerc.h:2791
playerc_log_set_filename
PLAYERC_EXPORT int playerc_log_set_filename(playerc_log_t *device, const char *fname)
Change name of log file to write to.
playerc_rfid_t::tags_count
uint16_t tags_count
The number of RFID tags found.
Definition: playerc.h:3439
playerc_wsn_subscribe
PLAYERC_EXPORT int playerc_wsn_subscribe(playerc_wsn_t *device, int access)
Subscribe to the wsn device.
playerc_simulation_pause
PLAYERC_EXPORT int playerc_simulation_pause(playerc_simulation_t *device)
pause / unpause the simulation
playerc_dio_t
Dio proxy data.
Definition: playerc.h:1461
player_pose3d
A pose in space.
Definition: player.h:224
playerc_aio_destroy
PLAYERC_EXPORT void playerc_aio_destroy(playerc_aio_t *device)
Destroy a aio proxy.
playerc_limb_home_cmd
PLAYERC_EXPORT int playerc_limb_home_cmd(playerc_limb_t *device)
Command the end effector to move home.
playerc_callback_fn_t
PLAYERC_EXPORT typedef void(* playerc_callback_fn_t)(void *data)
Typedef for proxy callback function.
Definition: playerc.h:442
player_fiducial_geom
Request/reply: Get geometry.
Definition: player_interfaces.h:1717
playerc_ranger_t::points_count
uint32_t points_count
Number of scan points.
Definition: playerc.h:3073
playerc_position1d_set_cmd_pos_with_vel
PLAYERC_EXPORT int playerc_position1d_set_cmd_pos_with_vel(playerc_position1d_t *device, double pos, double vel, int state)
Set the target position with movement velocity -.
playerc_actarray_t::actuators_geom_count
uint32_t actuators_geom_count
The number of actuators we have geometry for.
Definition: playerc.h:996
playerc_opaque_t::data
uint8_t * data
Data.
Definition: playerc.h:2468
playerc_ranger_t::element_poses
player_pose3d_t * element_poses
Geometry of each individual element in the device (e.g.
Definition: playerc.h:3051
playerc_wsn_t::node_type
uint32_t node_type
The type of WSN node.
Definition: playerc.h:3616
playerc_imu_t
IMU proxy state data.
Definition: playerc.h:3559
playerc_client_get_devlist
PLAYERC_EXPORT int playerc_client_get_devlist(playerc_client_t *client)
Get the list of available device ids.
playerc_ptz_create
PLAYERC_EXPORT playerc_ptz_t * playerc_ptz_create(playerc_client_t *client, int index)
Create a ptz proxy.
playerc_ranger_unsubscribe
PLAYERC_EXPORT int playerc_ranger_unsubscribe(playerc_ranger_t *device)
Un-subscribe from the ranger device.
playerc_fiducial_destroy
PLAYERC_EXPORT void playerc_fiducial_destroy(playerc_fiducial_t *device)
Destroy a fiducial proxy.
playerc_power_t::percent
double percent
Battery charge (percent full).
Definition: playerc.h:2893
playerc_wsn_t::node_id
uint32_t node_id
The ID of the WSN node.
Definition: playerc.h:3618
_playerc_client_t::lasttime
double lasttime
Server time stamp on the previous packet.
Definition: playerc.h:527
playerc_client_read_nonblock
PLAYERC_EXPORT int playerc_client_read_nonblock(playerc_client_t *client)
Read and process a packet (nonblocking)
_playerc_client_t::data_received
int data_received
Definition: playerc.h:501
playerc_actarray_home_cmd
PLAYERC_EXPORT int playerc_actarray_home_cmd(playerc_actarray_t *device, int joint)
Command a joint (or, if joint is -1, the whole array) to go to its home position. ...
playerc_actarray_destroy
PLAYERC_EXPORT void playerc_actarray_destroy(playerc_actarray_t *device)
Destroy an actarray proxy.
playerc_speechrecognition_create
PLAYERC_EXPORT playerc_speechrecognition_t * playerc_speechrecognition_create(playerc_client_t *client, int index)
Create a speech recognition proxy.
playerc_vectormap_t::extent
player_extent2d_t extent
Boundary area.
Definition: playerc.h:2405
playerc_blobfinder_unsubscribe
PLAYERC_EXPORT int playerc_blobfinder_unsubscribe(playerc_blobfinder_t *device)
Un-subscribe from the blobfinder device.
playerc_graphics2d_subscribe
PLAYERC_EXPORT int playerc_graphics2d_subscribe(playerc_graphics2d_t *device, int access)
Subscribe to the graphics2d device.
playerc_limb_create
PLAYERC_EXPORT playerc_limb_t * playerc_limb_create(playerc_client_t *client, int index)
Create a limb proxy.
playerc_bumper_t::poses
player_bumper_define_t * poses
Pose of each bumper relative to robot (mm, mm, deg, mm, mm).
Definition: playerc.h:1349
playerc_audio_t::mixer_data
player_audio_mixer_channel_list_t mixer_data
current channel data
Definition: playerc.h:1095
player_point_3d
A point in 3D space.
Definition: player.h:190
playerc_gripper_close_cmd
PLAYERC_EXPORT int playerc_gripper_close_cmd(playerc_gripper_t *device)
Command the gripper to close.
playerc_planner_t::waypoint_count
int waypoint_count
Number of waypoints in the plan.
Definition: playerc.h:2534
playerc_planner_set_cmd_pose
PLAYERC_EXPORT int playerc_planner_set_cmd_pose(playerc_planner_t *device, double gx, double gy, double ga)
Set the goal pose (gx, gy, ga)
player_fiducial_item
Info on a single detected fiducial.
Definition: player_interfaces.h:1688
_playerc_device_t::user_data
void * user_data
Extra user data for this device.
Definition: playerc.h:857
playerc_gps_t::vdop
double vdop
Vertical dilution of precision.
Definition: playerc.h:1585
playerc_map_t::cells
char * cells
Occupancy for each cell (empty = -1, unknown = 0, occupied = +1)
Definition: playerc.h:2356
playerc_mclient_t
Definition: playerc.h:391
playerc_localize_t::pending_time
double pending_time
The timestamp on the last reading processed.
Definition: playerc.h:2234
playerc_vectormap_destroy
PLAYERC_EXPORT void playerc_vectormap_destroy(playerc_vectormap_t *device)
Destroy a vectormap proxy.
playerc_pointcloud3d_create
PLAYERC_EXPORT playerc_pointcloud3d_t * playerc_pointcloud3d_create(playerc_client_t *client, int index)
Create a pointcloud3d proxy.
playerc_rfid_subscribe
PLAYERC_EXPORT int playerc_rfid_subscribe(playerc_rfid_t *device, int access)
Subscribe to the rfid device.
playerc_actarray_power
PLAYERC_EXPORT int playerc_actarray_power(playerc_actarray_t *device, uint8_t enable)
Turn the power to the array on or off.
playerc_gripper_open_cmd
PLAYERC_EXPORT int playerc_gripper_open_cmd(playerc_gripper_t *device)
Command the gripper to open.
playerc_sonar_subscribe
PLAYERC_EXPORT int playerc_sonar_subscribe(playerc_sonar_t *device, int access)
Subscribe to the sonar device.
playerc_limb_subscribe
PLAYERC_EXPORT int playerc_limb_subscribe(playerc_limb_t *device, int access)
Subscribe to the limb device.
playerc_planner_enable
PLAYERC_EXPORT int playerc_planner_enable(playerc_planner_t *device, int state)
Enable / disable the robot's motion.
playerc_simulation_unsubscribe
PLAYERC_EXPORT int playerc_simulation_unsubscribe(playerc_simulation_t *device)
Un-subscribe from the simulation device.
playerc_blinkenlight_blink
PLAYERC_EXPORT int playerc_blinkenlight_blink(playerc_blinkenlight_t *device, uint32_t id, float period, float duty_cycle)
Make the light blink, setting the period in seconds and the mark/space ratiom (0.0 to 1...
playerc_blackboard
BlackBoard proxy.
Definition: playerc.h:1178
playerc_imu_subscribe
PLAYERC_EXPORT int playerc_imu_subscribe(playerc_imu_t *device, int access)
Subscribe to the imu device.
playerc_gripper_retrieve_cmd
PLAYERC_EXPORT int playerc_gripper_retrieve_cmd(playerc_gripper_t *device)
Command the gripper to retrieve.
playerc_stereo_unsubscribe
PLAYERC_EXPORT int playerc_stereo_unsubscribe(playerc_stereo_t *device)
Un-subscribe from the stereo device.
playerc_laser_set_config
PLAYERC_EXPORT 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)
Configure the laser.
playerc_actarray_t::base_pos
player_point_3d_t base_pos
The position of the base of the actarray.
Definition: playerc.h:1001
playerc_blackboard_get_entry
PLAYERC_EXPORT int playerc_blackboard_get_entry(playerc_blackboard_t *device, const char *key, const char *group, player_blackboard_entry_t **entry)
Get the current value of a key, without subscribing.
playerc_ranger_t::min_range
double min_range
Minimum range [m].
Definition: playerc.h:3035
_playerc_device_t::drivername
char drivername[PLAYER_MAX_DRIVER_STRING_LEN]
The driver name.
Definition: playerc.h:828
_playerc_client_t::retry_time
double retry_time
How long to sleep, in seconds, to sleep between reconnect attempts.
Definition: playerc.h:483
playerc_speechrecognition_subscribe
PLAYERC_EXPORT int playerc_speechrecognition_subscribe(playerc_speechrecognition_t *device, int access)
Subscribe to the speech recognition device.
playerc_position2d_get_geom
PLAYERC_EXPORT int playerc_position2d_get_geom(playerc_position2d_t *device)
Get the position2d geometry.
player_audio_wav
Data: Raw audio data.
Definition: player_interfaces.h:1466
playerc_sonar_t::pose_count
int pose_count
Number of pose values.
Definition: playerc.h:3153
playerc_audio_mixer_multchannels_cmd
PLAYERC_EXPORT int playerc_audio_mixer_multchannels_cmd(playerc_audio_t *device, player_audio_mixer_channel_list_t *levels)
Command to set mixer levels for multiple channels.
player_blackboard_entry_t
struct player_blackboard_entry player_blackboard_entry_t
Vectormap feature data.
playerc_blobfinder_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1298
playerc_graphics3d_create
PLAYERC_EXPORT playerc_graphics3d_t * playerc_graphics3d_create(playerc_client_t *client, int index)
Create a graphics3d device proxy.
playerc_position3d_t::stall
int stall
Stall flag [0, 1].
Definition: playerc.h:2800
playerc_position3d_unsubscribe
PLAYERC_EXPORT int playerc_position3d_unsubscribe(playerc_position3d_t *device)
Un-subscribe from the position3d device.
playerc_client_connect
PLAYERC_EXPORT int playerc_client_connect(playerc_client_t *client)
Connect to the server.
playerc_stereo_create
PLAYERC_EXPORT playerc_stereo_t * playerc_stereo_create(playerc_client_t *client, int index)
Create a stereo proxy.
playerc_device_set_intprop
PLAYERC_EXPORT int playerc_device_set_intprop(playerc_device_t *device, char *property, int32_t value)
Set an integer property.
playerc_blackboard_unsubscribe_from_group
PLAYERC_EXPORT int playerc_blackboard_unsubscribe_from_group(playerc_blackboard_t *device, const char *group)
Unsubscribe from a group.
playerc_vectormap_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2401
playerc_blackboard::py_private
void * py_private
Kludge to get around python callback issues.
Definition: playerc.h:1185
playerc_laser_t::intensity
int * intensity
Scan reflection intensity values (0-3).
Definition: playerc.h:2006
_playerc_device_t::subscribed
int subscribed
The subscribe flag is non-zero if the device has been successfully subscribed (read-only).
Definition: playerc.h:832
playerc_actarray_subscribe
PLAYERC_EXPORT int playerc_actarray_subscribe(playerc_actarray_t *device, int access)
Subscribe to the actarray device.
playerc_aio_unsubscribe
PLAYERC_EXPORT int playerc_aio_unsubscribe(playerc_aio_t *device)
Un-subscribe from the aio device.
playerc_camera_create
PLAYERC_EXPORT playerc_camera_t * playerc_camera_create(playerc_client_t *client, int index)
Create a camera proxy.
playerc_ptz_set
PLAYERC_EXPORT int playerc_ptz_set(playerc_ptz_t *device, double pan, double tilt, double zoom)
Set the pan, tilt and zoom values.
playerc_position3d_enable
PLAYERC_EXPORT int playerc_position3d_enable(playerc_position3d_t *device, int enable)
Enable/disable the motors.
_playerc_client_t::id
void * id
A useful ID for identifying devices; mostly used by other language bindings.
Definition: playerc.h:464
playerc_imu_destroy
PLAYERC_EXPORT void playerc_imu_destroy(playerc_imu_t *device)
Destroy a imu proxy.
playerc_blobfinder_t::width
unsigned int width
Image dimensions (pixels).
Definition: playerc.h:1301
playerc_ranger_intns_config
PLAYERC_EXPORT int playerc_ranger_intns_config(playerc_ranger_t *device, uint8_t value)
Turn intensity data on or off.
playerc_planner_t::wx
double wx
Current waypoint location (m, m, radians)
Definition: playerc.h:2526
playerc_client_set_transport
PLAYERC_EXPORT void playerc_client_set_transport(playerc_client_t *client, unsigned int transport)
Set the transport type.
playerc_camera_t::format
int format
Image format (e.g., RGB888).
Definition: playerc.h:1407
playerc_wifi_t
Wifi device proxy.
Definition: playerc.h:3229
playerc_device_info_t::addr
player_devaddr_t addr
Player id of the device.
Definition: playerc.h:451
playerc_vectormap_t::layers_data
player_vectormap_layer_data_t ** layers_data
Layer data.
Definition: playerc.h:2409
playerc_speechrecognition_destroy
PLAYERC_EXPORT void playerc_speechrecognition_destroy(playerc_speechrecognition_t *device)
Destroy a speech recognition proxy.
player_audio_mixer_channel_list_detail
Player mixer channels.
Definition: player_interfaces.h:1572
playerc_position3d_set_pose_with_vel
PLAYERC_EXPORT int playerc_position3d_set_pose_with_vel(playerc_position3d_t *device, player_pose3d_t pos, player_pose3d_t vel)
Set the target pose (pos,vel) define desired position and motion speed.
playerc_log_subscribe
PLAYERC_EXPORT int playerc_log_subscribe(playerc_log_t *device, int access)
Subscribe to the log device.
playerc_laser_printout
PLAYERC_EXPORT void playerc_laser_printout(playerc_laser_t *device, const char *prefix)
Print a human-readable summary of the laser state on stdout.
playerc_ranger_t::bearings
double * bearings
Scan bearings in the XY plane [radians].
Definition: playerc.h:3070
playerc_pointcloud3d_t::points
playerc_pointcloud3d_element_t * points
The list of 3D pointcloud elements.
Definition: playerc.h:3483
playerc_vectormap_unsubscribe
PLAYERC_EXPORT int playerc_vectormap_unsubscribe(playerc_vectormap_t *device)
Un-subscribe from the vectormap device.
playerc_sonar_get_geom
PLAYERC_EXPORT int playerc_sonar_get_geom(playerc_sonar_t *device)
Get the sonar geometry.
playerc_audio_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:1083
playerc_audio_wav_rec
PLAYERC_EXPORT int playerc_audio_wav_rec(playerc_audio_t *device)
Request to record a single audio block Value is returned into wav_data, block length is determined by...
playerc_simulation_subscribe
PLAYERC_EXPORT int playerc_simulation_subscribe(playerc_simulation_t *device, int access)
Subscribe to the simulation device.
playerc_simulation_create
PLAYERC_EXPORT playerc_simulation_t * playerc_simulation_create(playerc_client_t *client, int index)
Create a new simulation proxy.
playerc_actarray_unsubscribe
PLAYERC_EXPORT int playerc_actarray_unsubscribe(playerc_actarray_t *device)
Un-subscribe from the actarray device.
playerc_audio_sample_rec
PLAYERC_EXPORT int playerc_audio_sample_rec(playerc_audio_t *device, int index, uint32_t length)
Request to record new sample.
playerc_wifi_unsubscribe
PLAYERC_EXPORT int playerc_wifi_unsubscribe(playerc_wifi_t *device)
Un-subscribe from the wifi device.
playerc_audio_unsubscribe
PLAYERC_EXPORT int playerc_audio_unsubscribe(playerc_audio_t *device)
Un-subscribe from the audio device.
player_segment
A line segment, used to construct vector-based maps.
Definition: player.h:287
playerc_aio_subscribe
PLAYERC_EXPORT int playerc_aio_subscribe(playerc_aio_t *device, int access)
Subscribe to the aio device.
playerc_aio_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:932
playerc_ranger_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3022
playerc_client_set_retry_time
PLAYERC_EXPORT void playerc_client_set_retry_time(playerc_client_t *client, double time)
Set the connection retry sleep time.
playerc_map_subscribe
PLAYERC_EXPORT int playerc_map_subscribe(playerc_map_t *device, int access)
Subscribe to the map device.
playerc_wsn_t::data_packet
player_wsn_node_data_t data_packet
The WSN node's data packet.
Definition: playerc.h:3622
player_bumper_define
The geometry of a single bumper.
Definition: player_interfaces.h:1929
playerc_audio_mixer_channel_cmd
PLAYERC_EXPORT int playerc_audio_mixer_channel_cmd(playerc_audio_t *device, uint32_t index, float amplitude, uint8_t active)
Command to set mixer levels for a single channel.
playerc_camera_t::fdiv
int fdiv
Some images (such as disparity maps) use scaled pixel values; for these images, fdiv specifies the sc...
Definition: playerc.h:1412
playerc_speech_unsubscribe
PLAYERC_EXPORT int playerc_speech_unsubscribe(playerc_speech_t *device)
Un-subscribe from the speech device.
playerc_wsn_power
PLAYERC_EXPORT int playerc_wsn_power(playerc_wsn_t *device, int node_id, int group_id, int value)
Put the node in sleep mode (0) or wake it up (1).
playerc_wifi_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:3232
playerc_localize_create
PLAYERC_EXPORT playerc_localize_t * playerc_localize_create(playerc_client_t *client, int index)
Create a localize proxy.
playerc_position1d_set_cmd_pos
PLAYERC_EXPORT int playerc_position1d_set_cmd_pos(playerc_position1d_t *device, double pos, int state)
Set the target position.
_playerc_device_t::addr
player_devaddr_t addr
Device address.
Definition: playerc.h:825
playerc_limb_t
Limb device data.
Definition: playerc.h:2131
playerc_position3d_t::vel_x
double vel_x
Linear velocity (m/s).
Definition: playerc.h:2794
playerc_ranger_power_config
PLAYERC_EXPORT int playerc_ranger_power_config(playerc_ranger_t *device, uint8_t value)
Turn device power on or off.
playerc_localize_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2216
playerc_limb_t::info
playerc_device_t info
Device info; must be at the start of all device structures.
Definition: playerc.h:2134
playerc_actarray_current_cmd
PLAYERC_EXPORT int playerc_actarray_current_cmd(playerc_actarray_t *device, int joint, float current)
Command a joint in the array to move with a specified current.
playerc_simulation_reset
PLAYERC_EXPORT int playerc_simulation_reset(playerc_simulation_t *device)
reset the simulation state
playerc_simulation_set_pose2d
PLAYERC_EXPORT int playerc_simulation_set_pose2d(playerc_simulation_t *device, char *name, double gx, double gy, double ga)
Set the 2D pose of a named simulation object.
playerc_gripper_stop_cmd
PLAYERC_EXPORT int playerc_gripper_stop_cmd(playerc_gripper_t *device)
Command the gripper to stop.
playerc_client_item_t
Definition: playerc.h:383
playerc_fiducial_get_geom
PLAYERC_EXPORT int playerc_fiducial_get_geom(playerc_fiducial_t *device)
Get the fiducial geometry.
playerc_position1d_set_cmd_vel
PLAYERC_EXPORT int playerc_position1d_set_cmd_vel(playerc_position1d_t *device, double vel, int state)
Set the target speed.
playerc_audio_create
PLAYERC_EXPORT playerc_audio_t * playerc_audio_create(playerc_client_t *client, int index)
Create an audio proxy.
playerc_position2d_create
PLAYERC_EXPORT playerc_position2d_t * playerc_position2d_create(playerc_client_t *client, int index)
Create a position2d device proxy.
playerc_power_destroy
PLAYERC_EXPORT void playerc_power_destroy(playerc_power_t *device)
Destroy a power device proxy.
playerc_rfid_unsubscribe
PLAYERC_EXPORT int playerc_rfid_unsubscribe(playerc_rfid_t *device)
Un-subscribe from the rfid device.
playerc_audio_t::state
uint32_t state
current driver state
Definition: playerc.h:1098
playerc_planner_unsubscribe
PLAYERC_EXPORT int playerc_planner_unsubscribe(playerc_planner_t *device)
Un-subscribe from the planner device.
player_audio_mixer_channel_list
Player mixer channels.
Definition: player_interfaces.h:1533
player_graphics3d_draw_mode_t
enum player_graphics3d_draw_mode player_graphics3d_draw_mode_t
Drawmode: enumeration that defines the drawing mode.
playerc_position1d_t::stall
int stall
Stall flag [0, 1].
Definition: playerc.h:2605
player_pointcloud3d_stereo_element
Definition: player_interfaces.h:5221
playerc_audio_subscribe
PLAYERC_EXPORT int playerc_audio_subscribe(playerc_audio_t *device, int access)
Subscribe to the audio device.
playerc_blackboard::on_blackboard_event
void(* on_blackboard_event)(struct playerc_blackboard *, player_blackboard_entry_t)
Function to be called when a key is updated.
Definition: playerc.h:1183
playerc_localize_particle_t
struct playerc_localize_particle playerc_localize_particle_t
Hypothesis data.
playerc_actarray_t::actuators_data
player_actarray_actuator_t * actuators_data
The actuator data, geometry and motor state.
Definition: playerc.h:994
playerc_gripper_unsubscribe
PLAYERC_EXPORT int playerc_gripper_unsubscribe(playerc_gripper_t *device)
Un-subscribe from the gripper device.
playerc_stereo_destroy
PLAYERC_EXPORT void playerc_stereo_destroy(playerc_stereo_t *device)
Destroy a stereo proxy.
playerc_position1d_t::status
int status
Status bitfield of extra data in the following order:
Definition: playerc.h:2618
playerc_ir_get_geom
PLAYERC_EXPORT int playerc_ir_get_geom(playerc_ir_t *device)
Get the ir geometry.
player_localize_hypoth
Hypothesis format.
Definition: player_interfaces.h:2333
playerc_gps_subscribe
PLAYERC_EXPORT int playerc_gps_subscribe(playerc_gps_t *device, int access)
Subscribe to the gps device.
playerc_client_disconnect_retry
PLAYERC_EXPORT int playerc_client_disconnect_retry(playerc_client_t *client)
Disconnect from the server, with potential retry.
playerc_client_read
PLAYERC_EXPORT void * playerc_client_read(playerc_client_t *client)
Read data from the server (blocking).
playerc_log_create
PLAYERC_EXPORT playerc_log_t * playerc_log_create(playerc_client_t *client, int index)
Create a log proxy.
playerc_ir_create
PLAYERC_EXPORT playerc_ir_t * playerc_ir_create(playerc_client_t *client, int index)
Create a ir proxy.
playerc_actarray_t::base_orientation
player_orientation_3d_t base_orientation
The orientation of the base of the actarray.
Definition: playerc.h:1003
playerc_vectormap_get_map_info
PLAYERC_EXPORT int playerc_vectormap_get_map_info(playerc_vectormap_t *device)
Get the vectormap metadata, which is stored in the proxy.
playerc_actarray_t
Actarray device data.
Definition: playerc.h:986
playerc_blinkenlight_destroy
PLAYERC_EXPORT void playerc_blinkenlight_destroy(playerc_blinkenlight_t *device)
Destroy a blinkenlight proxy.
playerc_client_addcallback
PLAYERC_EXPORT int playerc_client_addcallback(playerc_client_t *client, struct _playerc_device_t *device, playerc_callback_fn_t callback, void *data)
Add user callbacks (called when new data arrives).
playerc_actarray_brakes
PLAYERC_EXPORT int playerc_actarray_brakes(playerc_actarray_t *device, uint8_t enable)
Turn the brakes of all actuators in the array that have them on or off.

Last updated 12 September 2005 21:38:45