Player

• Frontpage
• Contents

User

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

Developer

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

Online

Homepage
Download
Project
Bugs
Help

player.h

/*
 *  Player - One Hell of a Robot Server
 *  Copyright (C) 2000
 *     Brian Gerkey, Kasper Stoy, Richard Vaughan, & Andrew Howard
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*
 * Desc: Player communication packet structures and codes
 * CVS:  $Id: player.h,v 1.85 2006/02/28 02:54:05 rtv Exp $
 */


#ifndef PLAYER_H
#define PLAYER_H

/* Include values from the configure script */
#include "playerconfig.h"

#define PLAYER_MAX_MESSAGE_SIZE 8388608 /*8MB*/

#define PLAYER_MAX_PAYLOAD_SIZE (PLAYER_MAX_MESSAGE_SIZE - sizeof(player_msghdr_t))

#define PLAYER_MAX_DRIVER_STRING_LEN 64

#define PLAYER_MAX_DEVICES             256

#define PLAYER_MSGQUEUE_DEFAULT_MAXLEN 32

#define PLAYER_IDENT_STRING    "Player v."

#define PLAYER_IDENT_STRLEN 32

#define PLAYER_KEYLEN       32

#define PLAYER_MSGTYPE_DATA      1

#define PLAYER_MSGTYPE_CMD       2

#define PLAYER_MSGTYPE_REQ       3

#define PLAYER_MSGTYPE_RESP_ACK  4

#define PLAYER_MSGTYPE_SYNCH     5

#define PLAYER_MSGTYPE_RESP_NACK 6

#define PLAYER_NULL_CODE           256 // /dev/null analogue
#define PLAYER_PLAYER_CODE         1   // the server itself
#define PLAYER_POWER_CODE          2   // power subsystem
#define PLAYER_GRIPPER_CODE        3   // gripper
#define PLAYER_POSITION2D_CODE     4   // device that moves about in the plane
#define PLAYER_SONAR_CODE          5   // fixed range-finder
#define PLAYER_LASER_CODE          6   // scanning range-finder
#define PLAYER_BLOBFINDER_CODE     7   // visual blobfinder
#define PLAYER_PTZ_CODE            8   // pan-tilt-zoom unit
#define PLAYER_AUDIO_CODE          9   // audio I/O
#define PLAYER_FIDUCIAL_CODE       10  // fiducial detector
#define PLAYER_SPEECH_CODE         12  // speech I/O
#define PLAYER_GPS_CODE            13  // GPS unit
#define PLAYER_BUMPER_CODE         14  // bumper array
#define PLAYER_TRUTH_CODE          15  // ground-truth (via Stage;
#define PLAYER_DIO_CODE            20  // digital I/O
#define PLAYER_AIO_CODE            21  // analog I/O
#define PLAYER_IR_CODE             22  // IR array
#define PLAYER_WIFI_CODE           23  // wifi card status
#define PLAYER_WAVEFORM_CODE       24  // fetch raw waveforms
#define PLAYER_LOCALIZE_CODE       25  // localization
#define PLAYER_MCOM_CODE           26  // multicoms
#define PLAYER_SOUND_CODE          27  // sound file playback
#define PLAYER_AUDIODSP_CODE       28  // audio dsp I/O
#define PLAYER_AUDIOMIXER_CODE     29  // audio I/O
#define PLAYER_POSITION3D_CODE     30  // 3-D position
#define PLAYER_SIMULATION_CODE     31  // simulators
#define PLAYER_SERVICE_ADV_CODE    32  // LAN service advertisement
#define PLAYER_BLINKENLIGHT_CODE   33  // blinking lights
#define PLAYER_NOMAD_CODE          34  // Nomad robot
#define PLAYER_CAMERA_CODE         40  // camera device
#define PLAYER_MAP_CODE            42  // get a map
#define PLAYER_PLANNER_CODE        44  // 2D motion planner
#define PLAYER_LOG_CODE            45  // log read/write control
#define PLAYER_ENERGY_CODE         46  // energy consumption
//#define PLAYER_MOTOR_CODE          47  // motor interface
#define PLAYER_JOYSTICK_CODE       49  // Joytstick
#define PLAYER_SPEECH_RECOGNITION_CODE  50  // speech recognition
#define PLAYER_OPAQUE_CODE         51  // plugin interface
#define PLAYER_POSITION1D_CODE     52  // 1-D position
#define PLAYER_ACTARRAY_CODE       53  // Actuator Array interface
#define PLAYER_LIMB_CODE           54  // Limb interface
#define PLAYER_GRAPHICS2D_CODE     55  // Graphics2D interface
#define PLAYER_RFID_CODE           56  // RFID reader interface

#define PLAYER_ACTARRAY_STRING        "actarray"
#define PLAYER_AIO_STRING             "aio"
#define PLAYER_AUDIO_STRING           "audio"
#define PLAYER_AUDIODSP_STRING        "audiodsp"
#define PLAYER_AUDIOMIXER_STRING      "audiomixer"
#define PLAYER_BLINKENLIGHT_STRING    "blinkenlight"
#define PLAYER_BLOBFINDER_STRING      "blobfinder"
#define PLAYER_BUMPER_STRING          "bumper"
#define PLAYER_CAMERA_STRING          "camera"
#define PLAYER_ENERGY_STRING          "energy"
#define PLAYER_DIO_STRING             "dio"
#define PLAYER_GRIPPER_STRING         "gripper"
#define PLAYER_FIDUCIAL_STRING        "fiducial"
#define PLAYER_GPS_STRING             "gps"
#define PLAYER_IR_STRING              "ir"
#define PLAYER_JOYSTICK_STRING        "joystick"
#define PLAYER_LASER_STRING           "laser"
#define PLAYER_LIMB_STRING            "limb"
#define PLAYER_LOCALIZE_STRING        "localize"
#define PLAYER_LOG_STRING             "log"
#define PLAYER_MAP_STRING             "map"
#define PLAYER_MCOM_STRING            "mcom"
//#define PLAYER_MOTOR_STRING           "motor"
#define PLAYER_NOMAD_STRING           "nomad"
#define PLAYER_NULL_STRING            "null"
#define PLAYER_OPAQUE_STRING          "opaque"
#define PLAYER_PLANNER_STRING         "planner"
#define PLAYER_PLAYER_STRING          "player"
#define PLAYER_POSITION1D_STRING      "position1d"
#define PLAYER_POSITION2D_STRING      "position2d"
#define PLAYER_POSITION3D_STRING      "position3d"
#define PLAYER_POWER_STRING           "power"
#define PLAYER_PTZ_STRING             "ptz"
#define PLAYER_RFID_STRING            "rfid"
#define PLAYER_SERVICE_ADV_STRING     "service_adv"
#define PLAYER_SIMULATION_STRING      "simulation"
#define PLAYER_SONAR_STRING           "sonar"
#define PLAYER_SOUND_STRING            "sound"
#define PLAYER_SPEECH_STRING          "speech"
#define PLAYER_SPEECH_RECOGNITION_STRING  "speech_recognition"
#define PLAYER_TRUTH_STRING           "truth"
#define PLAYER_WAVEFORM_STRING        "waveform"
#define PLAYER_WIFI_STRING            "wifi"
#define PLAYER_GRAPHICS2D_STRING       "graphics2d"

typedef struct player_devaddr
{
  uint32_t host;
  uint32_t robot;
  uint16_t interf;
  uint16_t index;
} player_devaddr_t;

typedef struct player_msghdr
{
  player_devaddr_t addr;
  uint8_t type;
  uint8_t subtype;
  double timestamp;
  uint32_t seq;
  uint32_t size;
} player_msghdr_t;
typedef struct player_point_2d
{
  float px;
  float py;
} player_point_2d_t;


typedef struct player_point_3d
{
  float px;
  float py;
  float pz;
} player_point_3d_t;


typedef struct player_pose
{
  float px;
  float py;
  float pa;
} player_pose_t;

typedef struct player_pose3d
{
  float px;
  float py;
  float pz;
  float proll;
  float ppitch;
  float pyaw;
} player_pose3d_t;

typedef struct player_bbox
{
  float sw;
  float sl;
} player_bbox_t;

typedef struct player_bbox3d
{
  float sw;
  float sl;
  float sh;
} player_bbox3d_t;

typedef struct player_segment
{
  float x0;
  float y0;
  float x1;
  float y1;
} player_segment_t;

typedef struct player_color
{
  uint8_t alpha;
  uint8_t red;
  uint8_t green;
  uint8_t blue;
} player_color_t;


// /////////////////////////////////////////////////////////////////////////////
//
//             Here starts the alphabetical list of interfaces
//                       (please keep it that way)
//
// /////////////////////////////////////////////////////////////////////////////

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_ACTARRAY_NUM_ACTUATORS     16

#define PLAYER_ACTARRAY_ACTSTATE_IDLE     1

#define PLAYER_ACTARRAY_ACTSTATE_MOVING   2

#define PLAYER_ACTARRAY_ACTSTATE_BRAKED   3

#define PLAYER_ACTARRAY_ACTSTATE_STALLED  4

#define PLAYER_ACTARRAY_TYPE_LINEAR       1

#define PLAYER_ACTARRAY_TYPE_ROTARY       2

#define PLAYER_ACTARRAY_POWER_REQ         1

#define PLAYER_ACTARRAY_BRAKES_REQ        2

#define PLAYER_ACTARRAY_GET_GEOM_REQ      3

#define PLAYER_ACTARRAY_SPEED_REQ         4

#define PLAYER_ACTARRAY_POS_CMD           1

#define PLAYER_ACTARRAY_SPEED_CMD         2

#define PLAYER_ACTARRAY_HOME_CMD          3

#define PLAYER_ACTARRAY_DATA_STATE        1

typedef struct player_actarray_actuator
{
  float position;
  float speed;
  uint8_t state;
} player_actarray_actuator_t;

typedef struct player_actarray_data
{
  uint32_t actuators_count;
  player_actarray_actuator_t actuators[PLAYER_ACTARRAY_NUM_ACTUATORS];
} player_actarray_data_t;

typedef struct player_actarray_actuatorgeom
{
  uint8_t type;
  float min;
  float centre;
  float max;
  float home;
  float config_speed;
  uint8_t hasbrakes;
} player_actarray_actuatorgeom_t;

typedef struct player_actarray_geom
{
  uint32_t actuators_count;
  player_actarray_actuatorgeom_t actuators[PLAYER_ACTARRAY_NUM_ACTUATORS];
} player_actarray_geom_t;

typedef struct player_actarray_position_cmd
{
  int32_t joint;
  float position;
} player_actarray_position_cmd_t;

typedef struct player_actarray_speed_cmd
{
  int32_t joint;
  float speed;
} player_actarray_speed_cmd_t;

typedef struct player_actarray_home_cmd
{
  int32_t joint;
} player_actarray_home_cmd_t;

typedef struct player_actarray_power_config
{
  uint8_t value;
} player_actarray_power_config_t;

typedef struct player_actarray_brakes_config
{
  uint8_t value;
} player_actarray_brakes_config_t;

typedef struct player_actarray_speed_config
{
  int32_t joint;
  float speed;
} player_actarray_speed_config_t;
// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_AIO_MAX_INPUTS  8

#define PLAYER_AIO_MAX_OUTPUTS 8

#define PLAYER_AIO_CMD_STATE              1

#define PLAYER_AIO_DATA_STATE             1

typedef struct player_aio_data
{
  uint32_t voltages_count;
  float voltages[PLAYER_AIO_MAX_INPUTS];
} player_aio_data_t;

typedef struct player_aio_cmd
{
  uint32_t id;
  float voltage;
} player_aio_cmd_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_AUDIO_DATA_BUFFER_SIZE    20

#define PLAYER_AUDIO_COMMAND_BUFFER_SIZE (3*sizeof(short))

#define PLAYER_AUDIO_PAIRS               5

typedef struct player_audio_data
{
  uint32_t frequency_count;
  float frequency[PLAYER_AUDIO_PAIRS];
  uint32_t amplitude_count;
  float amplitude[PLAYER_AUDIO_PAIRS];
} player_audio_data_t;

typedef struct player_audio_cmd
{
  float frequency;
  float amplitude;
  float duration;
} player_audio_cmd_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_AUDIODSP_MAX_FREQS 8

#define PLAYER_AUDIODSP_MAX_BITSTRING_LEN 64

#define PLAYER_AUDIODSP_SET_CONFIG 1

#define PLAYER_AUDIODSP_GET_CONFIG 2

#define PLAYER_AUDIODSP_PLAY_TONE  1

#define PLAYER_AUDIODSP_PLAY_CHIRP 2

#define PLAYER_AUDIODSP_REPLAY     3

#define PLAYER_AUDIODSP_DATA_TONES 1

typedef struct player_audiodsp_data
{
  uint32_t frequency_count;
  float frequency[PLAYER_AUDIODSP_MAX_FREQS];
  uint32_t amplitude_count;
  float amplitude[PLAYER_AUDIODSP_MAX_FREQS];

} player_audiodsp_data_t;

typedef struct player_audiodsp_cmd
{
  float frequency;
  float amplitude;
  float duration;
  uint32_t bit_string_count;
  uint8_t bit_string[PLAYER_AUDIODSP_MAX_BITSTRING_LEN];
} player_audiodsp_cmd_t;

typedef struct player_audiodsp_config
{
  int32_t format;
  float frequency;
  uint32_t channels;
} player_audiodsp_config_t;
// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_AUDIOMIXER_SET_MASTER 1

#define PLAYER_AUDIOMIXER_SET_PCM    2

#define PLAYER_AUDIOMIXER_SET_LINE   3

#define PLAYER_AUDIOMIXER_SET_MIC    4

#define PLAYER_AUDIOMIXER_SET_IGAIN  5

#define PLAYER_AUDIOMIXER_SET_OGAIN  6

#define PLAYER_AUDIOMIXER_GET_LEVELS 1

typedef struct player_audiomixer_cmd
{
  uint32_t left;
  uint32_t right;

} player_audiomixer_cmd_t;

typedef struct player_audiomixer_config
{
  uint32_t master_left;
  uint32_t master_right;
  uint32_t pcm_left;
  uint32_t pcm_right;
  uint32_t line_left;
  uint32_t line_right;
  uint32_t mic_left;
  uint32_t mic_right;
  uint32_t i_gain;
  uint32_t o_gain;
} player_audiomixer_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BLINKENLIGHT_DATA_STATE 1

#define PLAYER_BLINKENLIGHT_CMD_STATE      1

#define PLAYER_BLINKENLIGHT_CMD_POWER      2

#define PLAYER_BLINKENLIGHT_CMD_COLOR      3

#define PLAYER_BLINKENLIGHT_CMD_PERIOD     4

#define PLAYER_BLINKENLIGHT_CMD_DUTYCYCLE  5

typedef struct player_blinkenlight_data
{
  uint8_t enable;
  float period;
  float dutycycle;
  player_color_t color;
} player_blinkenlight_data_t;

typedef struct player_blinkenlight_cmd
{
  uint8_t enable;
  float period;
  float dutycycle;
  player_color_t color;
} player_blinkenlight_cmd_t;

typedef struct player_blinkenlight_cmd_power
{
  uint8_t enable;
} player_blinkenlight_cmd_power_t;

typedef struct player_blinkenlight_cmd_color
{
  player_color_t color;
} player_blinkenlight_cmd_color_t;

typedef struct player_blinkenlight_cmd_period
{
  float period;
} player_blinkenlight_cmd_period_t;

typedef struct player_blinkenlight_cmd_dutycycle
{
  float dutycycle;
} player_blinkenlight_cmd_dutycycle_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BLOBFINDER_MAX_BLOBS 256

#define PLAYER_BLOBFINDER_DATA_BLOBS 1

#define PLAYER_BLOBFINDER_REQ_SET_COLOR         1

#define PLAYER_BLOBFINDER_REQ_SET_IMAGER_PARAMS 2

//#define PLAYER_BLOBFINDER_DATA_BLOBS 1


typedef struct player_blobfinder_blob
{
  uint32_t id;
  uint32_t color;
  uint32_t area;
  uint32_t x;
  uint32_t y;
  uint32_t left;
  uint32_t right;
  uint32_t top;
  uint32_t bottom;
  float range;
} player_blobfinder_blob_t;

typedef struct player_blobfinder_data
{
  uint32_t width;
  uint32_t height;
  uint32_t blobs_count;
  player_blobfinder_blob_t blobs[PLAYER_BLOBFINDER_MAX_BLOBS];
} player_blobfinder_data_t;


typedef struct player_blobfinder_color_config
{
  uint32_t rmin;
  uint32_t rmax;
  uint32_t gmin;
  uint32_t gmax;
  uint32_t bmin;
  uint32_t bmax;
} player_blobfinder_color_config_t;


typedef struct player_blobfinder_imager_config
{
  int32_t brightness;
  int32_t contrast;
  int32_t  colormode;
  int32_t  autogain;
} player_blobfinder_imager_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BUMPER_MAX_SAMPLES 32

#define PLAYER_BUMPER_GET_GEOM    1

#define PLAYER_BUMPER_DATA_STATE  1

#define PLAYER_BUMPER_DATA_GEOM  2

typedef struct player_bumper_data
{
  uint32_t bumpers_count;
  uint8_t bumpers[PLAYER_BUMPER_MAX_SAMPLES];
} player_bumper_data_t;

typedef struct player_bumper_define
{
  player_pose_t pose;
  float length;
  float radius;
} player_bumper_define_t;

typedef struct player_bumper_geom
{
  uint32_t bumper_def_count;
  player_bumper_define_t bumper_def[PLAYER_BUMPER_MAX_SAMPLES];
} player_bumper_geom_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_CAMERA_DATA_STATE             1

#define PLAYER_CAMERA_IMAGE_WIDTH  1920

#define PLAYER_CAMERA_IMAGE_HEIGHT 1080

#define PLAYER_CAMERA_IMAGE_SIZE  (PLAYER_CAMERA_IMAGE_WIDTH * PLAYER_CAMERA_IMAGE_HEIGHT * 4)

#define PLAYER_CAMERA_FORMAT_MONO8  1

#define PLAYER_CAMERA_FORMAT_MONO16 2

#define PLAYER_CAMERA_FORMAT_RGB565 4

#define PLAYER_CAMERA_FORMAT_RGB888 5

#define PLAYER_CAMERA_COMPRESS_RAW  0

#define PLAYER_CAMERA_COMPRESS_JPEG 1

typedef struct player_camera_data
{
  uint32_t width;
  uint32_t height;
  uint32_t bpp;
  uint32_t format;
  uint32_t fdiv;
  uint32_t compression;
  uint32_t image_count;
  uint8_t image[PLAYER_CAMERA_IMAGE_SIZE];
} player_camera_data_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_DIO_DATA_VALUES 1

#define PLAYER_DIO_CMD_VALUES 1

typedef struct player_dio_data
{
  uint32_t count;
  uint32_t digin;
} player_dio_data_t;


typedef struct player_dio_cmd
{
  uint32_t count;
  uint32_t digout;
} player_dio_cmd_t;

/* REMOVE ENERGY DEVICE - USE POWER INSTEAD - RTV 2005.12.04 */

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_ENERGY_DATA_STATE 1

#define PLAYER_ENERGY_SET_CHARGING_POLICY_REQ 1

typedef struct player_energy_data
{
  float joules;
  float watts;
  int32_t charging;
} player_energy_data_t;

typedef struct player_energy_chargepolicy_config
{
  uint8_t enable_input;
  uint8_t enable_output;
} player_energy_chargepolicy_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_FIDUCIAL_MAX_SAMPLES 32

#define PLAYER_FIDUCIAL_DATA_SCAN 1

#define PLAYER_FIDUCIAL_REQ_GET_GEOM     1

#define PLAYER_FIDUCIAL_REQ_GET_FOV      2

#define PLAYER_FIDUCIAL_REQ_SET_FOV      3

#define PLAYER_FIDUCIAL_REQ_GET_ID       7

#define PLAYER_FIDUCIAL_REQ_SET_ID       8

typedef struct player_fiducial_item
{
  int32_t id;
  player_pose3d_t pose;
  player_pose3d_t upose;
} player_fiducial_item_t;


typedef struct player_fiducial_data
{
  uint32_t fiducials_count;
  player_fiducial_item_t fiducials[PLAYER_FIDUCIAL_MAX_SAMPLES];

} player_fiducial_data_t;

typedef struct player_fiducial_geom
{
  player_pose_t pose;
  player_bbox_t size;
  player_bbox_t fiducial_size;
} player_fiducial_geom_t;

typedef struct player_fiducial_fov
{
  float min_range;
  float max_range;
  float view_angle;
} player_fiducial_fov_t;

typedef struct player_fiducial_id
{
  uint32_t id;
} player_fiducial_id_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_GPS_DATA_STATE 1

typedef struct player_gps_data
{
  uint32_t time_sec;
  uint32_t time_usec;
  int32_t latitude;
  int32_t longitude;
  int32_t altitude;
  double utm_e;
  double utm_n;
  uint32_t quality;
  uint32_t num_sats;
  uint32_t hdop;
  uint32_t vdop;
  double err_horz;
  double err_vert;
} player_gps_data_t;



#define PLAYER_GRAPHICS2D_MAX_POINTS 64

#define PLAYER_GRAPHICS2D_CMD_CLEAR 1

#define PLAYER_GRAPHICS2D_CMD_POINTS 2

#define PLAYER_GRAPHICS2D_CMD_POLYLINE 3

#define PLAYER_GRAPHICS2D_CMD_POLYGON 4

typedef struct player_graphics2d_cmd_points
{
  uint16_t count;
  player_point_2d_t points[PLAYER_GRAPHICS2D_MAX_POINTS];
  player_color_t color;
} player_graphics2d_cmd_points_t;

typedef struct player_graphics2d_cmd_polyline
{
  uint16_t count;
  player_point_2d_t points[PLAYER_GRAPHICS2D_MAX_POINTS];
  player_color_t color;
} player_graphics2d_cmd_polyline_t;

typedef struct player_graphics2d_cmd_polygon
{
  uint16_t count;
  player_point_2d_t points[PLAYER_GRAPHICS2D_MAX_POINTS];
  player_color_t color;
  player_color_t fill_color;
  uint8_t filled;
} player_graphics2d_cmd_polygon_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_GRIPPER_DATA_STATE 1

#define PLAYER_GRIPPER_CMD_STATE 1

#define PLAYER_GRIPPER_REQ_GET_GEOM 1

#define GRIPopen   1

#define GRIPclose  2

#define GRIPstop   3

#define LIFTup     4

#define LIFTdown   5

#define LIFTstop   6

#define GRIPstore  7

#define GRIPdeploy 8

#define GRIPhalt   15

#define GRIPpress  16

#define LIFTcarry  17

typedef struct player_gripper_data
{
  uint32_t state;
  uint32_t beams;
} player_gripper_data_t;

typedef struct player_gripper_cmd
{
  uint32_t cmd;
  uint32_t arg;
} player_gripper_cmd_t;


typedef struct player_gripper_geom
{
  player_pose_t pose;
  player_bbox_t size;
} player_gripper_geom_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_IR_MAX_SAMPLES 32

#define PLAYER_IR_POSE        1

#define PLAYER_IR_POWER       2

#define PLAYER_IR_DATA_RANGES 1

typedef struct player_ir_data
{
  uint32_t voltages_count;
  float voltages[PLAYER_IR_MAX_SAMPLES];
  uint32_t ranges_count;
  float ranges[PLAYER_IR_MAX_SAMPLES];
} player_ir_data_t;

typedef struct player_ir_pose
{
  uint32_t poses_count;
  player_pose_t poses[PLAYER_IR_MAX_SAMPLES];
} player_ir_pose_t;

typedef struct player_ir_power_req
{
  uint8_t state;
} player_ir_power_req_t;
// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_JOYSTICK_DATA_STATE 1

typedef struct player_joystick_data
{
  int32_t xpos;
  int32_t ypos;
  int32_t xscale;
  int32_t yscale;
  uint32_t buttons;
} player_joystick_data_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_LASER_MAX_SAMPLES  1024

#define PLAYER_LASER_DATA_SCAN        1

#define PLAYER_LASER_DATA_SCANPOSE    2

#define PLAYER_LASER_REQ_GET_GEOM     1

#define PLAYER_LASER_REQ_SET_CONFIG   2

#define PLAYER_LASER_REQ_GET_CONFIG   3

#define PLAYER_LASER_REQ_POWER        4

typedef struct player_laser_data
{
  float min_angle;
  float max_angle;
  float resolution;
  float max_range;
  uint32_t ranges_count;
  float ranges[PLAYER_LASER_MAX_SAMPLES];
  uint32_t intensity_count;
  uint8_t intensity[PLAYER_LASER_MAX_SAMPLES];
  uint32_t id;
} player_laser_data_t;

typedef struct player_laser_data_scanpose
{
  player_laser_data_t scan;
  player_pose_t pose;
} player_laser_data_scanpose_t;

typedef struct player_laser_geom
{
  player_pose_t pose;
  player_bbox_t size;
} player_laser_geom_t;

typedef struct player_laser_config
{
  float min_angle;
  float max_angle;
  float resolution;
  float max_range;
  float range_res;
  uint8_t  intensity;
} player_laser_config_t;

typedef struct player_laser_power_config
{
  uint8_t state;
} player_laser_power_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_LIMB_STATE_IDLE        1

#define PLAYER_LIMB_STATE_BRAKED      2

#define PLAYER_LIMB_STATE_MOVING      3

#define PLAYER_LIMB_STATE_OOR         4

#define PLAYER_LIMB_STATE_COLL        5

#define PLAYER_LIMB_DATA              1

#define PLAYER_LIMB_HOME_CMD          1

#define PLAYER_LIMB_STOP_CMD          2

#define PLAYER_LIMB_SETPOSE_CMD       3

#define PLAYER_LIMB_SETPOSITION_CMD   4

#define PLAYER_LIMB_VECMOVE_CMD       5

#define PLAYER_LIMB_POWER_REQ         1

#define PLAYER_LIMB_BRAKES_REQ        2

#define PLAYER_LIMB_GEOM_REQ          3

#define PLAYER_LIMB_SPEED_REQ         4

typedef struct player_limb_data
{
  player_point_3d_t position;
  player_point_3d_t approach;
  player_point_3d_t orientation;
  uint8_t state;
} player_limb_data_t;

typedef struct player_limb_home_cmd
{
} player_limb_home_cmd_t;

typedef struct player_limb_stop_cmd
{
} player_limb_stop_cmd_t;

typedef struct player_limb_setpose_cmd
{
  player_point_3d_t position;
  player_point_3d_t approach;
  player_point_3d_t orientation;
} player_limb_setpose_cmd_t;

typedef struct player_limb_setposition_cmd
{
  player_point_3d_t position;
} player_limb_setposition_cmd_t;

typedef struct player_limb_vecmove_cmd
{
  player_point_3d_t direction;
  float length;
} player_limb_vecmove_cmd_t;

typedef struct player_limb_power_req
{
  uint8_t value;
} player_limb_power_req_t;

typedef struct player_limb_brakes_req
{
  uint8_t value;
} player_limb_brakes_req_t;

typedef struct player_limb_geom_req
{
  player_point_3d_t basePos;
} player_limb_geom_req_t;

typedef struct player_limb_speed_req
{
  float speed;
} player_limb_speed_req_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_LOCALIZE_MAX_HYPOTHS   10

#define PLAYER_LOCALIZE_PARTICLES_MAX 100

#define PLAYER_LOCALIZE_DATA_HYPOTHS      1

#define PLAYER_LOCALIZE_REQ_SET_POSE      1

#define PLAYER_LOCALIZE_REQ_GET_PARTICLES 2

typedef struct player_localize_hypoth
{
  player_pose_t mean;
  double cov[3];
  double alpha;
} player_localize_hypoth_t;

typedef struct player_localize_data
{
  uint32_t pending_count;
  double pending_time;
  uint32_t hypoths_count;
  player_localize_hypoth_t hypoths[PLAYER_LOCALIZE_MAX_HYPOTHS];
} player_localize_data_t;

typedef struct player_localize_set_pose
{
  player_pose_t mean;
  double cov[3];
} player_localize_set_pose_t;

typedef struct player_localize_particle
{
  player_pose_t pose;
  double alpha;
} player_localize_particle_t;

typedef struct player_localize_get_particles
{
  player_pose_t mean;
  double variance;
  uint32_t particles_count;
  player_localize_particle_t particles[PLAYER_LOCALIZE_PARTICLES_MAX];
} player_localize_get_particles_t;

// /////////////////////////////////////////////////////////////////////////////
#define  PLAYER_LOG_TYPE_READ       1

#define  PLAYER_LOG_TYPE_WRITE      2

#define PLAYER_LOG_REQ_SET_WRITE_STATE  1

#define PLAYER_LOG_REQ_SET_READ_STATE   2

#define PLAYER_LOG_REQ_GET_STATE        3

#define PLAYER_LOG_REQ_SET_READ_REWIND  4

#define PLAYER_LOG_REQ_SET_FILENAME     5

typedef struct player_log_set_write_state
{
  uint8_t state;
} player_log_set_write_state_t;

typedef struct player_log_set_read_state
{
  uint8_t state;
} player_log_set_read_state_t;

typedef struct player_log_set_read_rewind
{
} player_log_set_read_rewind_t;

typedef struct player_log_get_state
{
  uint8_t type;
  uint8_t state;
} player_log_get_state_t;

typedef struct player_log_set_filename
{
  uint32_t filename_count;
  char filename[256];
} player_log_set_filename_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_MAP_MAX_TILE_SIZE 2097102

#define PLAYER_MAP_MAX_SEGMENTS 131068

#define PLAYER_MAP_DATA_INFO               1

#define PLAYER_MAP_REQ_GET_INFO            1

#define PLAYER_MAP_REQ_GET_DATA            2

#define PLAYER_MAP_REQ_GET_VECTOR          3

typedef struct player_map_info
{
  float scale;
  uint32_t width;
  uint32_t height;
  player_pose_t origin;
} player_map_info_t;

typedef struct player_map_data
{
  uint32_t col;
  uint32_t row;
  uint32_t width;
  uint32_t height;
  uint32_t data_count;
  int8_t data[PLAYER_MAP_MAX_TILE_SIZE];
} player_map_data_t;

typedef struct player_map_data_vector
{
  float minx;
  float maxx;
  float miny;
  float maxy;
  uint32_t segments_count;
  player_segment_t segments[PLAYER_MAP_MAX_SEGMENTS];
} player_map_data_vector_t;
// /////////////////////////////////////////////////////////////////////////////
#define MCOM_DATA_LEN            128

#define MCOM_DATA_BUFFER_SIZE    0

#define  MCOM_N_BUFS             10

#define MCOM_CHANNEL_LEN        8

#define  MCOM_EMPTY_STRING          "(EMPTY)"

#define  PLAYER_MCOM_PUSH         0

#define  PLAYER_MCOM_POP          1

#define  PLAYER_MCOM_READ         2

#define  PLAYER_MCOM_CLEAR        3

#define  PLAYER_MCOM_SET_CAPACITY 4

#define MCOM_COMMAND_BUFFER_SIZE (sizeof(player_mcom_config_t))

typedef struct player_mcom_data
{
  char full;
  uint32_t data_count;
  char data[MCOM_DATA_LEN];
} player_mcom_data_t;

typedef struct player_mcom_config
{
  uint32_t command;
  uint32_t type;
  uint32_t channel_count;
  int32_t channel[MCOM_CHANNEL_LEN];
  player_mcom_data_t data;
} player_mcom_config_t;

typedef struct player_mcom_return
{
  uint32_t type;
  uint32_t channel_count;
  int32_t channel[MCOM_CHANNEL_LEN];
  player_mcom_data_t data;
} player_mcom_return_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_PLANNER_MAX_WAYPOINTS 128

#define PLAYER_PLANNER_DATA_STATE 1

#define PLAYER_PLANNER_CMD_GOAL 1

#define PLAYER_PLANNER_REQ_GET_WAYPOINTS 1

#define PLAYER_PLANNER_REQ_ENABLE        2

typedef struct player_planner_data
{
  uint8_t valid;
  uint8_t done;
  player_pose_t pos;
  player_pose_t goal;
  player_pose_t waypoint;
  int32_t waypoint_idx;
  uint32_t waypoints_count;
} player_planner_data_t;

typedef struct player_planner_cmd
{
  player_pose_t goal;
} player_planner_cmd_t;

typedef struct player_planner_waypoints_req
{
  uint32_t waypoints_count;
  player_pose_t waypoints[PLAYER_PLANNER_MAX_WAYPOINTS];
} player_planner_waypoints_req_t;

typedef struct player_planner_enable_req
{
  uint8_t state;
} player_planner_enable_req_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_OPEN_MODE   1

#define PLAYER_CLOSE_MODE  2

#define PLAYER_ERROR_MODE  3


#define PLAYER_DATAMODE_PUSH  1

#define PLAYER_DATAMODE_PULL   2

#define PLAYER_PLAYER_REQ_DEVLIST     1

#define PLAYER_PLAYER_REQ_DRIVERINFO  2

#define PLAYER_PLAYER_REQ_DEV         3

#define PLAYER_PLAYER_REQ_DATA        4
#define PLAYER_PLAYER_REQ_DATAMODE    5
#define PLAYER_PLAYER_REQ_DATAFREQ    6
#define PLAYER_PLAYER_REQ_AUTH        7
#define PLAYER_PLAYER_REQ_NAMESERVICE 8
#define PLAYER_PLAYER_REQ_IDENT       9
#define PLAYER_PLAYER_REQ_ADD_REPLACE_RULE 10


typedef struct player_device_devlist
{
  uint32_t devices_count;
  player_devaddr_t devices[PLAYER_MAX_DEVICES];
} player_device_devlist_t;

typedef struct player_device_driverinfo
{
  player_devaddr_t addr;
  uint32_t driver_name_count;
  char driver_name[PLAYER_MAX_DRIVER_STRING_LEN];
} player_device_driverinfo_t;

typedef struct player_device_req
{
  player_devaddr_t addr;
  uint8_t access;
  uint32_t driver_name_count;
  char driver_name[PLAYER_MAX_DRIVER_STRING_LEN];
} player_device_req_t;

typedef struct player_device_data_req
{
} player_device_data_req_t;

typedef struct player_device_datamode_req
{
  uint8_t mode;

} player_device_datamode_req_t;


typedef struct player_device_datafreq_req
{
  uint32_t frequency;
} player_device_datafreq_req_t;


typedef struct player_device_auth_req
{
  uint32_t auth_key_count;
  uint8_t auth_key[PLAYER_KEYLEN];

} player_device_auth_req_t;


typedef struct player_device_nameservice_req
{
  uint32_t name_count;
  uint8_t name[PLAYER_MAX_DRIVER_STRING_LEN];
  uint16_t port;
} player_device_nameservice_req_t;

typedef struct player_add_replace_rule_req
{
  int32_t interf;
  int32_t index;
  int32_t type;
  int32_t subtype;
  int32_t replace ;
} player_add_replace_rule_req_t;


// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POSITION1D_GET_GEOM          1

#define PLAYER_POSITION1D_MOTOR_POWER       2

#define PLAYER_POSITION1D_VELOCITY_MODE     3

#define PLAYER_POSITION1D_POSITION_MODE     4

#define PLAYER_POSITION1D_SET_ODOM          5

#define PLAYER_POSITION1D_RESET_ODOM        6

#define PLAYER_POSITION1D_SPEED_PID         7

#define PLAYER_POSITION1D_POSITION_PID      8

#define PLAYER_POSITION1D_SPEED_PROF        9

#define PLAYER_POSITION1D_DATA_STATE      1

#define PLAYER_POSITION1D_DATA_GEOM       2

#define PLAYER_POSITION1D_CMD_STATE       1

typedef struct player_position1d_data
{
  float pos;
  float vel;
  uint8_t stall;
} player_position1d_data_t;

typedef struct player_position1d_cmd
{
  float pos;
  float vel;
  uint8_t state;
  uint32_t type;
} player_position1d_cmd_t;

typedef struct player_position1d_geom
{
  player_pose_t pose;
  player_bbox_t size;
} player_position1d_geom_t;

typedef struct player_position1d_power_config
{
  uint8_t state;
} player_position1d_power_config_t;

typedef struct player_position1d_velocity_mode_config
{
  uint32_t value;
} player_position1d_velocity_mode_config_t;

typedef struct player_position1d_reset_odom_config
{
  uint32_t value;
} player_position1d_reset_odom_config_t;

typedef struct player_position1d_position_mode
{
  uint32_t state;
} player_position1d_position_mode_req_t;

typedef struct player_position1d_set_odom
{
  float pos;
} player_position1d_set_odom_req_t;

typedef struct player_position1d_speed_pid
{
  float kp;
  float ki;
  float kd;
} player_position1d_speed_pid_req_t;

typedef struct player_position1d_position_pid
{
  float kp;
  float ki;
  float kd;
} player_position1d_position_pid_req_t;

typedef struct player_position1d_speed_prof
{
  float speed;
  float acc;
} player_position1d_speed_prof_req_t;
// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POSITION2D_REQ_GET_GEOM          1

#define PLAYER_POSITION2D_REQ_MOTOR_POWER       2

#define PLAYER_POSITION2D_REQ_VELOCITY_MODE     3

#define PLAYER_POSITION2D_REQ_POSITION_MODE     4

#define PLAYER_POSITION2D_REQ_SET_ODOM          5

#define PLAYER_POSITION2D_REQ_RESET_ODOM        6

#define PLAYER_POSITION2D_REQ_SPEED_PID         7

#define PLAYER_POSITION2D_REQ_POSITION_PID      8

#define PLAYER_POSITION2D_REQ_SPEED_PROF        9

#define PLAYER_POSITION2D_DATA_STATE             1

#define PLAYER_POSITION2D_DATA_GEOM              2

#define PLAYER_POSITION2D_CMD_VEL                1

#define PLAYER_POSITION2D_CMD_POS              2

#define PLAYER_POSITION2D_CMD_CAR              3

typedef struct player_position2d_data
{
  player_pose_t pos;
  player_pose_t vel;
  uint8_t stall;
} player_position2d_data_t;

typedef struct player_position2d_cmd_vel
{
  player_pose_t vel;
  uint8_t state;
} player_position2d_cmd_vel_t;

typedef struct player_position2d_cmd_pos
{
  player_pose_t pos;
  uint8_t state;
} player_position2d_cmd_pos_t;

typedef struct player_position2d_cmd_car
{
  double velocity;
  double angle;
} player_position2d_cmd_car_t;


typedef struct player_position2d_geom
{
  player_pose_t pose;
  player_bbox_t size;
} player_position2d_geom_t;

typedef struct player_position2d_power_config
{
  uint8_t state;
} player_position2d_power_config_t;

typedef struct player_position2d_velocity_mode_config
{
  uint32_t value;
} player_position2d_velocity_mode_config_t;

typedef struct player_position2d_reset_odom_config
{
} player_position2d_reset_odom_config_t;

typedef struct player_position2d_position_mode_req
{
  uint32_t state;
} player_position2d_position_mode_req_t;

typedef struct player_position2d_set_odom_req
{
  player_pose_t pose;
} player_position2d_set_odom_req_t;

typedef struct player_position2d_speed_pid_req
{
  float kp;
  float ki;
  float kd;
} player_position2d_speed_pid_req_t;

typedef struct player_position2d_position_pid_req
{
  float kp;
  float ki;
  float kd;
} player_position2d_position_pid_req_t;

typedef struct player_position2d_speed_prof_req
{
  float speed;
  float acc;
} player_position2d_speed_prof_req_t;
// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POSITION3D_DATA_STATE 1

#define PLAYER_POSITION3D_DATA_GEOMETRY 2

#define  PLAYER_POSITION3D_CMD_SET_VEL      1

#define  PLAYER_POSITION3D_CMD_SET_POS      2

#define PLAYER_POSITION3D_GET_GEOM          1

#define PLAYER_POSITION3D_MOTOR_POWER       2

#define PLAYER_POSITION3D_VELOCITY_MODE     3

#define PLAYER_POSITION3D_POSITION_MODE     4

#define PLAYER_POSITION3D_RESET_ODOM        5

#define PLAYER_POSITION3D_SET_ODOM          6

#define PLAYER_POSITION3D_SPEED_PID         7

#define PLAYER_POSITION3D_POSITION_PID      8

#define PLAYER_POSITION3D_SPEED_PROF        9

typedef struct player_position3d_data
{
  player_pose3d_t pos;
  player_pose3d_t vel;
  uint8_t stall;
} player_position3d_data_t;

typedef struct player_position3d_cmd_pos
{
  player_pose3d_t pos;
  uint8_t state;
} player_position3d_cmd_pos_t;

typedef struct player_position3d_cmd_vel
{
  player_pose3d_t vel;
  uint8_t state;
} player_position3d_cmd_vel_t;

typedef struct player_position3d_geom
{
  player_pose3d_t pose;
  player_bbox3d_t size;
} player_position3d_geom_t;

typedef struct player_position3d_power_config
{
  uint8_t state;
} player_position3d_power_config_t;

typedef struct player_position3d_position_mode_req
{
  uint32_t value;
} player_position3d_position_mode_req_t;

typedef struct player_position3d_velocity_mode_config
{
  uint32_t value;
} player_position3d_velocity_mode_config_t;

typedef struct player_position3d_set_odom_req
{
  player_pose3d_t pos;
} player_position3d_set_odom_req_t;

typedef struct player_position3d_reset_odom_config
{
} player_position3d_reset_odom_config_t;

typedef struct player_position3d_speed_pid_req
{
  float kp;
  float ki;
  float kd;
} player_position3d_speed_pid_req_t;

typedef struct player_position3d_position_pid_req
{
  float kp;
  float ki;
  float kd;
} player_position3d_position_pid_req_t;

typedef struct player_position3d_speed_prof_req
{
  float speed;
  float acc;
} player_position3d_speed_prof_req_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POWER_DATA_STATE 1

#define PLAYER_POWER_SET_CHARGING_POLICY_REQ 1

#define PLAYER_POWER_MASK_VOLTS 1
#define PLAYER_POWER_MASK_WATTS 2
#define PLAYER_POWER_MASK_JOULES 4
#define PLAYER_POWER_MASK_PERCENT 8
#define PLAYER_POWER_MASK_CHARGING 16

typedef struct player_power_data
{
  uint32_t valid;

  float  volts;
  float percent;
  float joules;
  float watts;
  int32_t charging;

} player_power_data_t;


typedef struct player_power_chargepolicy_config
{
  uint8_t enable_input;
  uint8_t enable_output;
} player_power_chargepolicy_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_PTZ_MAX_CONFIG_LEN  32

#define PLAYER_PTZ_VELOCITY_CONTROL 0

#define PLAYER_PTZ_POSITION_CONTROL 1

#define PLAYER_PTZ_REQ_GENERIC         1

#define PLAYER_PTZ_REQ_CONTROL_MODE    2

#define PLAYER_PTZ_REQ_AUTOSERVO       3

#define PLAYER_PTZ_REQ_GEOM            4

#define PLAYER_PTZ_DATA_STATE      1

#define PLAYER_PTZ_DATA_GEOM       2

#define PLAYER_PTZ_CMD_STATE       1

typedef struct player_ptz_data
{
  float pan;
  float tilt;
  float zoom;
  float panspeed;
  float tiltspeed;
} player_ptz_data_t;

typedef struct player_ptz_cmd
{
  float pan;
  float tilt;
  float zoom;
  float panspeed;
  float tiltspeed;
} player_ptz_cmd_t;

typedef struct player_ptz_geom
{
  player_pose3d_t pos;
  player_bbox3d_t size;
} player_ptz_geom_t;

typedef struct player_ptz_req_generic
{
  uint32_t  config_count;
  uint32_t  config[PLAYER_PTZ_MAX_CONFIG_LEN];
} player_ptz_req_generic_t;

typedef struct player_ptz_req_control_mode
{
  uint32_t mode;
} player_ptz_req_control_mode_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SIMULATION_IDENTIFIER_MAXLEN 64

#define PLAYER_SIMULATION_REQ_SET_POSE2D        1

#define PLAYER_SIMULATION_REQ_GET_POSE2D        2

typedef struct player_simulation_data
{
  uint8_t data;
} player_simulation_data_t;

typedef struct player_simulation_cmd
{
  uint8_t cmd;
} player_simulation_cmd_t;

typedef struct player_simulation_pose2d_req
{
  uint32_t name_count;
  char name[PLAYER_SIMULATION_IDENTIFIER_MAXLEN];
  player_pose_t pose;
} player_simulation_pose2d_req_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SONAR_MAX_SAMPLES 64

#define PLAYER_SONAR_REQ_GET_GEOM    1

#define PLAYER_SONAR_REQ_POWER       2

#define PLAYER_SONAR_DATA_RANGES     1

#define PLAYER_SONAR_DATA_GEOM       2

typedef struct player_sonar_data
{
  uint32_t ranges_count;
  float ranges[PLAYER_SONAR_MAX_SAMPLES];
} player_sonar_data_t;

typedef struct player_sonar_geom
{
  uint32_t poses_count;
  player_pose_t poses[PLAYER_SONAR_MAX_SAMPLES];
} player_sonar_geom_t;

typedef struct player_sonar_power_config
{
  uint8_t state;
} player_sonar_power_config_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SOUND_CMD_IDX 1

typedef struct player_sound_cmd
{
  uint32_t index;
} player_sound_cmd_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SPEECH_MAX_STRING_LEN 256

#define PLAYER_SPEECH_CMD_SAY 1

typedef struct player_speech_cmd
{
  uint32_t string_count;
  char string[PLAYER_SPEECH_MAX_STRING_LEN];
} player_speech_cmd_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SPEECH_RECOGNITION_TEXT_LEN 256

#define PLAYER_SPEECH_RECOGNITION_DATA_STRING 1

typedef struct player_speech_recognition_data
{
  uint32_t text_count;
  char text[PLAYER_SPEECH_RECOGNITION_TEXT_LEN];
} player_speech_recognition_data_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_TRUTH_DATA_POSE 0x01

#define PLAYER_TRUTH_DATA_FIDUCIAL_ID 0x02

#define PLAYER_TRUTH_REQ_SET_POSE 0x03

#define PLAYER_TRUTH_REQ_SET_FIDUCIAL_ID 0x04

#define PLAYER_TRUTH_REQ_GET_FIDUCIAL_ID 0x05

typedef struct player_truth_pose
{
  player_pose3d_t pose;
}  player_truth_pose_t;

typedef struct player_truth_fiducial_id
{
  uint8_t subtype;
  int16_t id;
}  player_truth_fiducial_id_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_WAVEFORM_DATA_MAX 4096

#define PLAYER_WAVEFORM_DATA_SAMPLE 1

typedef struct player_waveform_data
{
  uint32_t rate;
  uint32_t depth;
  uint32_t data_count;
  uint8_t data[PLAYER_WAVEFORM_DATA_MAX];
} player_waveform_data_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_WIFI_MAX_LINKS   32

#define PLAYER_WIFI_QUAL_DBM     1

#define PLAYER_WIFI_QUAL_REL     2

#define PLAYER_WIFI_QUAL_UNKNOWN 3

#define PLAYER_WIFI_MODE_UNKNOWN 0

#define PLAYER_WIFI_MODE_AUTO    1

#define PLAYER_WIFI_MODE_ADHOC   2

#define PLAYER_WIFI_MODE_INFRA   3

#define PLAYER_WIFI_MODE_MASTER  4

#define PLAYER_WIFI_MODE_REPEAT  5

#define PLAYER_WIFI_MODE_SECOND  6

#define PLAYER_WIFI_MAC          1

#define PLAYER_WIFI_IWSPY_ADD    2

#define PLAYER_WIFI_IWSPY_DEL    3

#define PLAYER_WIFI_IWSPY_PING   4

#define PLAYER_WIFI_DATA_STATE 1

typedef struct player_wifi_link
{
  uint32_t mac_count;
  uint8_t mac[32];
  uint32_t ip_count;
  uint8_t ip[32];
  uint32_t essid_count;
  uint8_t essid[32];
  uint32_t mode;
  uint32_t freq;
  uint32_t encrypt;
  uint32_t qual;
  uint32_t level;
  uint32_t noise;
} player_wifi_link_t;

typedef struct player_wifi_data
{
  uint32_t links_count;
  player_wifi_link_t links[PLAYER_WIFI_MAX_LINKS];
  uint32_t throughput;
  uint32_t bitrate;
  uint32_t mode;
  uint32_t qual_type;
  uint32_t maxqual;
  uint32_t maxlevel;
  uint32_t maxnoise;
  char ap[32];
} player_wifi_data_t;

typedef struct player_wifi_mac_req
{
  uint32_t mac_count;
  uint8_t mac[32];
} player_wifi_mac_req_t;

typedef struct player_wifi_iwspy_addr_req
{
  char      address[32];
} player_wifi_iwspy_addr_req_t;

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_RFID_MAX_TAGS 30

#define PLAYER_RFID_MAX_GUID 8

#define PLAYER_RFID_DATA         1

#define PLAYER_RFID_REQ_POWER    1

#define PLAYER_RFID_REQ_READTAG  2

#define PLAYER_RFID_REQ_WRITETAG 3

#define PLAYER_RFID_REQ_LOCKTAG  4

typedef struct player_rfid_tag
{
  uint32_t type;
  uint32_t guid_count;
  char guid[PLAYER_RFID_MAX_GUID];
} player_rfid_tag_t;

typedef struct player_rfid_data
{
  uint32_t tags_count;
  player_rfid_tag_t tags[PLAYER_RFID_MAX_TAGS];
} player_rfid_data_t;

typedef struct player_rfid_cmd
{
  uint8_t temp;
} player_rfid_cmd_t;

#endif /* PLAYER_H */

---

Last updated 12 September 2005 21:38:45