player_interfaces.h

/* START OF AUTOGENERATED CODE */
/* This file or section was automatically generated by playerinterfacegen.py
To modify the interfaces in this file please edit their interface definition in libplayerinterface/interfaces/ */

#define PLAYER_PLAYER_CODE 1

#define PLAYER_PLAYER_STRING "player" 

// /////////////////////////////////////////////////////////////////////////////
#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_AUTH 7


#define PLAYER_PLAYER_REQ_NAMESERVICE 8


#define PLAYER_PLAYER_REQ_ADD_REPLACE_RULE 10


#define PLAYER_PLAYER_SYNCH_OK 1


#define PLAYER_PLAYER_SYNCH_OVERFLOW 2



#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_MSG_REPLACE_RULE_ACCEPT  0
#define PLAYER_PLAYER_MSG_REPLACE_RULE_REPLACE 1
#define PLAYER_PLAYER_MSG_REPLACE_RULE_IGNORE  2

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_datamode_req
{
  uint8_t mode;

} player_device_datamode_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_POWER_CODE 2

#define PLAYER_POWER_STRING "power" 

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

#define PLAYER_POWER_REQ_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_GRIPPER_CODE 3

#define PLAYER_GRIPPER_STRING "gripper" 

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

#define PLAYER_GRIPPER_REQ_GET_GEOM 1

#define PLAYER_GRIPPER_CMD_OPEN 1

#define PLAYER_GRIPPER_CMD_CLOSE 2

#define PLAYER_GRIPPER_CMD_STOP 3

#define PLAYER_GRIPPER_CMD_STORE 4

#define PLAYER_GRIPPER_CMD_RETRIEVE 5



#define PLAYER_GRIPPER_STATE_OPEN 1

#define PLAYER_GRIPPER_STATE_CLOSED 2

#define PLAYER_GRIPPER_STATE_MOVING 3

#define PLAYER_GRIPPER_STATE_ERROR 4


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

typedef struct player_gripper_geom
{
  player_pose3d_t pose;
  player_bbox3d_t outer_size;
  player_bbox3d_t inner_size;
  uint8_t num_beams;
  uint8_t capacity;
} player_gripper_geom_t;






 
#define PLAYER_POSITION2D_CODE 4

#define PLAYER_POSITION2D_STRING "position2d" 

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

#define PLAYER_POSITION2D_CMD_VEL_HEAD 4





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

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

typedef struct player_position2d_cmd_pos
{
  player_pose2d_t pos;
  player_pose2d_t vel;
  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_cmd_vel_head
{
  double velocity;
  double angle;
} player_position2d_cmd_vel_head_t;

typedef struct player_position2d_geom
{
  player_pose3d_t pose;
  player_bbox3d_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_position_mode_req
{
  uint32_t state;
} player_position2d_position_mode_req_t;

typedef struct player_position2d_set_odom_req
{
  player_pose2d_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_SONAR_CODE 5

#define PLAYER_SONAR_STRING "sonar" 

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

typedef struct player_sonar_geom
{
  uint32_t poses_count;
  player_pose3d_t *poses;
} player_sonar_geom_t;

typedef struct player_sonar_power_config
{
  uint8_t state;
} player_sonar_power_config_t;

#define PLAYER_LASER_CODE 6

#define PLAYER_LASER_STRING "laser" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_LASER_DATA_SCAN 1

#define PLAYER_LASER_DATA_SCANPOSE 2

#define PLAYER_LASER_DATA_SCANANGLE 3

#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

#define PLAYER_LASER_REQ_GET_ID 5

#define PLAYER_LASER_REQ_SET_FILTER 6



#define PLAYER_LASER_MAX_FILTER_PARAMS 8
#define PLAYER_LASER_FILTER_MEDIAN 1
#define PLAYER_LASER_FILTER_EDGE   2
#define PLAYER_LASER_FILTER_RANGE  3
#define PLAYER_LASER_FILTER_MEAN   4

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

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

typedef struct player_laser_data_scanangle
{
  float max_range;
  uint32_t ranges_count;
  float *ranges;
  uint32_t angles_count;
  float *angles;
  uint32_t intensity_count;
  uint8_t *intensity;
  uint32_t id;
} player_laser_data_scanangle_t;


typedef struct player_laser_geom
{
  player_pose3d_t pose;
  player_bbox3d_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;
  float scanning_frequency;
} player_laser_config_t;

typedef struct player_laser_power_config
{
  uint8_t state;
} player_laser_power_config_t;

typedef struct player_laser_get_id_config
{
  uint32_t serial_number;
} player_laser_get_id_config_t;

typedef struct player_laser_set_filter_config
{
  uint8_t filter_type;
  uint32_t parameters_count;
  float parameters[PLAYER_LASER_MAX_FILTER_PARAMS];
} player_laser_set_filter_config_t;


 
#define PLAYER_BLOBFINDER_CODE 7

#define PLAYER_BLOBFINDER_STRING "blobfinder" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BLOBFINDER_DATA_BLOBS 1


#define PLAYER_BLOBFINDER_REQ_SET_COLOR 1


#define PLAYER_BLOBFINDER_REQ_SET_IMAGER_PARAMS 2


#define PLAYER_BLOBFINDER_REQ_GET_COLOR 3


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


typedef struct player_blobfinder_color_config
{
  uint32_t channel;
  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_PTZ_CODE 8

#define PLAYER_PTZ_STRING "ptz" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_PTZ_REQ_GENERIC 1

#define PLAYER_PTZ_REQ_CONTROL_MODE 2

#define PLAYER_PTZ_REQ_GEOM 4

#define PLAYER_PTZ_REQ_STATUS 5

#define PLAYER_PTZ_DATA_STATE 1

#define PLAYER_PTZ_DATA_GEOM 2

#define PLAYER_PTZ_CMD_STATE 1



#define PLAYER_PTZ_VELOCITY_CONTROL 0

#define PLAYER_PTZ_POSITION_CONTROL 1


typedef struct player_ptz_data
{
  float pan;
  float tilt;
  float zoom;
  float panspeed;
  float tiltspeed;
  uint32_t status;
} 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_req_status
{
  uint32_t status;
} player_ptz_req_status_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_req_generic_t;

typedef struct player_ptz_req_control_mode
{
  uint32_t mode;
} player_ptz_req_control_mode_t;

 
#define PLAYER_AUDIO_CODE 9

#define PLAYER_AUDIO_STRING "audio" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_AUDIO_DATA_WAV_REC 1

#define PLAYER_AUDIO_DATA_SEQ 2

#define PLAYER_AUDIO_DATA_MIXER_CHANNEL 3

#define PLAYER_AUDIO_DATA_STATE 4

#define PLAYER_AUDIO_CMD_WAV_PLAY 1

#define PLAYER_AUDIO_CMD_WAV_STREAM_REC 2

#define PLAYER_AUDIO_CMD_SAMPLE_PLAY 3

#define PLAYER_AUDIO_CMD_SEQ_PLAY 4

#define PLAYER_AUDIO_CMD_MIXER_CHANNEL 5

#define PLAYER_AUDIO_REQ_WAV_REC 1

#define PLAYER_AUDIO_REQ_SAMPLE_LOAD 2

#define PLAYER_AUDIO_REQ_SAMPLE_RETRIEVE 3

#define PLAYER_AUDIO_REQ_SAMPLE_REC 4

#define PLAYER_AUDIO_REQ_MIXER_CHANNEL_LIST 5

#define PLAYER_AUDIO_REQ_MIXER_CHANNEL_LEVEL 6



#define PLAYER_AUDIO_STATE_STOPPED            0x00
#define PLAYER_AUDIO_STATE_PLAYING            0x01
#define PLAYER_AUDIO_STATE_RECORDING          0x02

#define PLAYER_AUDIO_DESCRIPTION_BITS         0xFF
#define PLAYER_AUDIO_BITS                     0x03

#define PLAYER_AUDIO_8BIT                     0

#define PLAYER_AUDIO_16BIT                    1

#define PLAYER_AUDIO_24BIT                    2

#define PLAYER_AUDIO_MONO                     0

#define PLAYER_AUDIO_STEREO                   4

#define PLAYER_AUDIO_FREQ                     0x18
#define PLAYER_AUDIO_FREQ_44k                 0
#define PLAYER_AUDIO_FREQ_11k                 8
#define PLAYER_AUDIO_FREQ_22k                 16
#define PLAYER_AUDIO_FREQ_48k                 24

#define PLAYER_AUDIO_FORMAT_BITS              0xFF00

#define PLAYER_AUDIO_FORMAT_NULL              0x0000
#define PLAYER_AUDIO_FORMAT_RAW               0x0100
#define PLAYER_AUDIO_FORMAT_MP3               0x0200
#define PLAYER_AUDIO_FORMAT_OGG               0x0300
#define PLAYER_AUDIO_FORMAT_FLAC              0x0400
#define PLAYER_AUDIO_FORMAT_AAC               0x0500



typedef struct player_audio_wav
{
  uint32_t data_count;
  uint8_t *data;
  uint32_t format;
} player_audio_wav_t;


typedef struct player_audio_seq_item
{
  float freq;
  float duration;
  float amplitude;
  player_bool_t link;
} player_audio_seq_item_t;


typedef struct player_audio_seq
{
  uint32_t tones_count;
  player_audio_seq_item_t *tones;
} player_audio_seq_t;


typedef struct player_audio_mixer_channel
{
  float amplitude;
  player_bool_t active;
  uint32_t index;
} player_audio_mixer_channel_t;



typedef struct player_audio_mixer_channel_list
{
  uint32_t channels_count;
  player_audio_mixer_channel_t *channels;
} player_audio_mixer_channel_list_t;



#define PLAYER_AUDIO_MIXER_CHANNEL_TYPE_INPUT 1

#define PLAYER_AUDIO_MIXER_CHANNEL_TYPE_OUTPUT 2

#define PLAYER_AUDIO_MIXER_CHANNEL_TYPE_SPECIAL 4

typedef struct player_audio_mixer_channel_detail
{
  uint32_t name_count;
  char *name;
  uint8_t caps;
} player_audio_mixer_channel_detail_t;



typedef struct player_audio_mixer_channel_list_detail
{
  uint32_t details_count;
  player_audio_mixer_channel_detail_t *details;
  int32_t default_output;
  int32_t default_input;
} player_audio_mixer_channel_list_detail_t;



typedef struct player_audio_sample
{
  player_audio_wav_t sample;
  int32_t index;
} player_audio_sample_t;

typedef struct player_audio_sample_item
{
  int32_t index;
} player_audio_sample_item_t;

typedef struct player_audio_sample_rec_req
{
  int32_t index;
  uint32_t length;
} player_audio_sample_rec_req_t;

typedef struct player_audio_state
{
  uint32_t state;
} player_audio_state_t;

 
#define PLAYER_FIDUCIAL_CODE 10

#define PLAYER_FIDUCIAL_STRING "fiducial" 

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

typedef struct player_fiducial_geom
{
  player_pose3d_t pose;
  player_bbox3d_t size;
  player_bbox2d_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_SPEECH_CODE 12

#define PLAYER_SPEECH_STRING "speech" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SPEECH_CMD_SAY 1



typedef struct player_speech_cmd
{
  uint32_t string_count;
  char *string;
} player_speech_cmd_t;


 
#define PLAYER_GPS_CODE 13

#define PLAYER_GPS_STRING "gps" 

// /////////////////////////////////////////////////////////////////////////////
#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_BUMPER_CODE 14

#define PLAYER_BUMPER_STRING "bumper" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BUMPER_DATA_STATE 1


#define PLAYER_BUMPER_DATA_GEOM 2


#define PLAYER_BUMPER_REQ_GET_GEOM 1


typedef struct player_bumper_data
{
  uint32_t bumpers_count;
  uint8_t *bumpers;
} player_bumper_data_t;

typedef struct player_bumper_define
{
  player_pose3d_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_geom_t;


 
#define PLAYER_DIO_CODE 20

#define PLAYER_DIO_STRING "dio" 

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


#define PLAYER_DIO_CMD_VALUES 1


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

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

#define PLAYER_AIO_CODE 21

#define PLAYER_AIO_STRING "aio" 

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

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

 
#define PLAYER_IR_CODE 22

#define PLAYER_IR_STRING "ir" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_IR_REQ_POSE 1

#define PLAYER_IR_REQ_POWER 2

#define PLAYER_IR_DATA_RANGES 1



typedef struct player_ir_data
{
  uint32_t voltages_count;
  float *voltages;
  uint32_t ranges_count;
  float *ranges;
} player_ir_data_t;

typedef struct player_ir_pose
{
  uint32_t poses_count;
  player_pose3d_t *poses;
} player_ir_pose_t;

typedef struct player_ir_power_req
{
  uint8_t state;
} player_ir_power_req_t;

 
#define PLAYER_WIFI_CODE 23

#define PLAYER_WIFI_STRING "wifi" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_WIFI_REQ_MAC 1

#define PLAYER_WIFI_REQ_IWSPY_ADD 2

#define PLAYER_WIFI_REQ_IWSPY_DEL 3

#define PLAYER_WIFI_REQ_IWSPY_PING 4

#define PLAYER_WIFI_DATA_STATE 1



#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

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;
  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_LOCALIZE_CODE 25

#define PLAYER_LOCALIZE_STRING "localize" 

// /////////////////////////////////////////////////////////////////////////////
#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_pose2d_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_data_t;

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

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

typedef struct player_localize_get_particles
{
  player_pose2d_t mean;
  double variance;
  uint32_t particles_count;
  player_localize_particle_t *particles;
} player_localize_get_particles_t;

 
#define PLAYER_POSITION3D_CODE 30

#define PLAYER_POSITION3D_STRING "position3d" 

// /////////////////////////////////////////////////////////////////////////////
#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_REQ_GET_GEOM 1

#define PLAYER_POSITION3D_REQ_MOTOR_POWER 2

#define PLAYER_POSITION3D_REQ_VELOCITY_MODE 3

#define PLAYER_POSITION3D_REQ_POSITION_MODE 4

#define PLAYER_POSITION3D_REQ_RESET_ODOM 5

#define PLAYER_POSITION3D_REQ_SET_ODOM 6

#define PLAYER_POSITION3D_REQ_SPEED_PID 7

#define PLAYER_POSITION3D_REQ_POSITION_PID 8

#define PLAYER_POSITION3D_REQ_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;
  player_pose3d_t vel;
  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_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_SIMULATION_CODE 31

#define PLAYER_SIMULATION_STRING "simulation" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SIMULATION_REQ_GET_POSE2D 1

#define PLAYER_SIMULATION_REQ_SET_POSE2D 2

#define PLAYER_SIMULATION_REQ_GET_POSE3D 3

#define PLAYER_SIMULATION_REQ_SET_POSE3D 4

#define PLAYER_SIMULATION_REQ_GET_PROPERTY 5

#define PLAYER_SIMULATION_REQ_SET_PROPERTY 6

#define PLAYER_SIMULATION_CMD_PAUSE 1

#define PLAYER_SIMULATION_CMD_RESET 2

#define PLAYER_SIMULATION_CMD_SAVE 3




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_pose2d_t pose;
} player_simulation_pose2d_req_t;

typedef struct player_simulation_pose3d_req
{
  uint32_t name_count;
  char *name;
  player_pose3d_t pose;
  double simtime;
} player_simulation_pose3d_req_t;

typedef struct player_simulation_property_req
{
  uint32_t name_count;
  char *name;
  uint32_t prop_count;
  char *prop;
  uint32_t index;
  uint32_t value_count;
  char *value;
} player_simulation_property_req_t;


 
#define PLAYER_BLINKENLIGHT_CODE 33

#define PLAYER_BLINKENLIGHT_STRING "blinkenlight" 

// /////////////////////////////////////////////////////////////////////////////
#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_FLASH 4


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
{
  uint16_t id;  
  uint8_t enable;
  float period;
  float dutycycle;
  player_color_t color;
} player_blinkenlight_cmd_t;

typedef struct player_blinkenlight_cmd_power
{
  uint16_t id;  
  uint8_t enable;
} player_blinkenlight_cmd_power_t;

typedef struct player_blinkenlight_cmd_color
{
  uint16_t id;  
  player_color_t color;
} player_blinkenlight_cmd_color_t;
        
typedef struct player_blinkenlight_cmd_flash
{
  uint16_t id;  
  float period;
  float dutycycle;  
} player_blinkenlight_cmd_flash_t;


 
#define PLAYER_CAMERA_CODE 40

#define PLAYER_CAMERA_STRING "camera" 

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


#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_data_t;

 
#define PLAYER_MAP_CODE 42

#define PLAYER_MAP_STRING "map" 

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




#define PLAYER_MAP_DATA_INFO               1
typedef struct player_map_info
{
  float scale;
  uint32_t width;
  uint32_t height;
  player_pose2d_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_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_data_vector_t;


 
#define PLAYER_PLANNER_CODE 44

#define PLAYER_PLANNER_STRING "planner" 

// /////////////////////////////////////////////////////////////////////////////
#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_pose2d_t pos;
  player_pose2d_t goal;
  player_pose2d_t waypoint;
  int32_t waypoint_idx;
  uint32_t waypoints_count;
} player_planner_data_t;

typedef struct player_planner_cmd
{
  player_pose2d_t goal;
} player_planner_cmd_t;

typedef struct player_planner_waypoints_req
{
  uint32_t waypoints_count;
  player_pose2d_t *waypoints;
} player_planner_waypoints_req_t;

typedef struct player_planner_enable_req
{
  uint8_t state;
} player_planner_enable_req_t;


 
#define PLAYER_LOG_CODE 45

#define PLAYER_LOG_STRING "log" 

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



#define  PLAYER_LOG_TYPE_READ       1

#define  PLAYER_LOG_TYPE_WRITE      2


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_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_JOYSTICK_CODE 49

#define PLAYER_JOYSTICK_STRING "joystick" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_JOYSTICK_DATA_STATE 1




 typedef struct player_joystick_data
 {
  int32_t pos[8];
  int32_t scale[8];
   uint32_t buttons;
   uint32_t axes_count;
 } player_joystick_data_t;
 


 
#define PLAYER_SPEECH_RECOGNITION_CODE 50

#define PLAYER_SPEECH_RECOGNITION_STRING "speech_recognition" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_SPEECH_RECOGNITION_DATA_STRING 1



typedef struct player_speech_recognition_data
{
  uint32_t text_count;
  char *text;
} player_speech_recognition_data_t;


 
#define PLAYER_OPAQUE_CODE 51

#define PLAYER_OPAQUE_STRING "opaque" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_OPAQUE_DATA_STATE 1

#define PLAYER_OPAQUE_CMD_DATA 1

#define PLAYER_OPAQUE_REQ_DATA 1



/* for backwards compatibility */
#define PLAYER_OPAQUE_REQ PLAYER_OPAQUE_REQ_DATA
#define PLAYER_OPAQUE_CMD PLAYER_OPAQUE_CMD_DATA

typedef struct player_opaque_data
{
  uint32_t data_count;
  uint8_t *data;
} player_opaque_data_t;


 
#define PLAYER_POSITION1D_CODE 52

#define PLAYER_POSITION1D_STRING "position1d" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POSITION1D_REQ_GET_GEOM 1

#define PLAYER_POSITION1D_REQ_MOTOR_POWER 2

#define PLAYER_POSITION1D_REQ_VELOCITY_MODE 3

#define PLAYER_POSITION1D_REQ_POSITION_MODE 4

#define PLAYER_POSITION1D_REQ_SET_ODOM 5

#define PLAYER_POSITION1D_REQ_RESET_ODOM 6

#define PLAYER_POSITION1D_REQ_SPEED_PID 7

#define PLAYER_POSITION1D_REQ_POSITION_PID 8

#define PLAYER_POSITION1D_REQ_SPEED_PROF 9

#define PLAYER_POSITION1D_DATA_STATE 1

#define PLAYER_POSITION1D_DATA_GEOM 2

#define PLAYER_POSITION1D_CMD_VEL 1

#define PLAYER_POSITION1D_CMD_POS 2



#define PLAYER_POSITION1D_STATUS_LIMIT_MIN 0

#define PLAYER_POSITION1D_STATUS_LIMIT_CEN 1

#define PLAYER_POSITION1D_STATUS_LIMIT_MAX 2

#define PLAYER_POSITION1D_STATUS_OC 3

#define PLAYER_POSITION1D_STATUS_TRAJ_COMPLETE 4

#define PLAYER_POSITION1D_STATUS_ENABLED 5

typedef struct player_position1d_data
{
  float pos;
  float vel;
  uint8_t stall;
  uint8_t status;

} player_position1d_data_t;

typedef struct player_position1d_cmd_vel
{
  float vel;
  uint8_t state;
} player_position1d_cmd_vel_t;

typedef struct player_position1d_cmd_pos
{
  float pos;
  float vel;
  uint8_t state;
} player_position1d_cmd_pos_t;

typedef struct player_position1d_geom
{
  player_pose3d_t pose;
  player_bbox3d_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_req
{
  uint32_t state;
} player_position1d_position_mode_req_t;

typedef struct player_position1d_set_odom_req
{
  float pos;
} player_position1d_set_odom_req_t;

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

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

typedef struct player_position1d_speed_prof_req
{
  float speed;
  float acc;
} player_position1d_speed_prof_req_t;

 
#define PLAYER_ACTARRAY_CODE 53

#define PLAYER_ACTARRAY_STRING "actarray" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_ACTARRAY_REQ_POWER 1


#define PLAYER_ACTARRAY_REQ_BRAKES 2


#define PLAYER_ACTARRAY_REQ_GET_GEOM 3


#define PLAYER_ACTARRAY_REQ_SPEED 4


#define PLAYER_ACTARRAY_REQ_ACCEL 5


#define PLAYER_ACTARRAY_CMD_POS 1


#define PLAYER_ACTARRAY_CMD_MULTI_POS 2


#define PLAYER_ACTARRAY_CMD_SPEED 3


#define PLAYER_ACTARRAY_CMD_MULTI_SPEED 4


#define PLAYER_ACTARRAY_CMD_HOME 5


#define PLAYER_ACTARRAY_CMD_CURRENT 6


#define PLAYER_ACTARRAY_CMD_MULTI_CURRENT 7


#define PLAYER_ACTARRAY_DATA_STATE 1


#define PLAYER_ACTARRAY_ACTSTATE_IDLE     1

#define PLAYER_ACTARRAY_ACTSTATE_MOVING   2

#define PLAYER_ACTARRAY_ACTSTATE_BRAKED   4

#define PLAYER_ACTARRAY_ACTSTATE_STALLED  8

#define PLAYER_ACTARRAY_TYPE_LINEAR       1

#define PLAYER_ACTARRAY_TYPE_ROTARY       2


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

typedef struct player_actarray_data
{
  uint32_t actuators_count;
  player_actarray_actuator_t *actuators;
  uint8_t motor_state;
} player_actarray_data_t;

typedef struct player_actarray_actuatorgeom
{
  uint8_t type;
  float length;
  player_orientation_3d_t orientation;
  player_point_3d_t axis;
  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_point_3d_t base_pos;
  player_orientation_3d_t base_orientation;
} player_actarray_geom_t;


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

typedef struct player_actarray_multi_position_cmd
{
  uint32_t positions_count;
  float *positions;
} player_actarray_multi_position_cmd_t;

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

typedef struct player_actarray_multi_speed_cmd
{
  uint32_t speeds_count;
  float *speeds;
} player_actarray_multi_speed_cmd_t;

typedef struct player_actarray_home_cmd
{
  int32_t joint;
} player_actarray_home_cmd_t;

typedef struct player_actarray_current_cmd
{
  int32_t joint;
  float current;
} player_actarray_current_cmd_t;

typedef struct player_actarray_multi_current_cmd
{
  uint32_t currents_count;
  float *currents;
} player_actarray_multi_current_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;


typedef struct player_actarray_accel_config
{
  int32_t joint;
  float accel;
} player_actarray_accel_config_t;



 
#define PLAYER_LIMB_CODE 54

#define PLAYER_LIMB_STRING "limb" 

// /////////////////////////////////////////////////////////////////////////////
#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_STATE 1

#define PLAYER_LIMB_CMD_HOME 1

#define PLAYER_LIMB_CMD_STOP 2

#define PLAYER_LIMB_CMD_SETPOSE 3

#define PLAYER_LIMB_CMD_SETPOSITION 4

#define PLAYER_LIMB_CMD_VECMOVE 5

#define PLAYER_LIMB_REQ_POWER 1

#define PLAYER_LIMB_REQ_BRAKES 2

#define PLAYER_LIMB_REQ_GEOM 3

#define PLAYER_LIMB_REQ_SPEED 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_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_GRAPHICS2D_CODE 55

#define PLAYER_GRAPHICS2D_STRING "graphics2d" 

// /////////////////////////////////////////////////////////////////////////////
#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
{
  uint32_t points_count;
  player_point_2d_t *points;
  player_color_t color;
} player_graphics2d_cmd_points_t;

typedef struct player_graphics2d_cmd_polyline
{
  uint32_t points_count;
  player_point_2d_t *points;
  player_color_t color;
} player_graphics2d_cmd_polyline_t;

typedef struct player_graphics2d_cmd_polygon
{
  uint32_t points_count;
  player_point_2d_t *points;
  player_color_t color;
  player_color_t fill_color;
  uint8_t filled;
} player_graphics2d_cmd_polygon_t;

 
#define PLAYER_RFID_CODE 56

#define PLAYER_RFID_STRING "rfid" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_RFID_DATA_TAGS 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_tag_t;

typedef struct player_rfid_data
{
  uint32_t tags_count;
  player_rfid_tag_t *tags;
} player_rfid_data_t;

 
#define PLAYER_WSN_CODE 57

#define PLAYER_WSN_STRING "wsn" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_WSN_DATA_STATE 1

#define PLAYER_WSN_CMD_DEVSTATE 1

#define PLAYER_WSN_REQ_POWER 1

#define PLAYER_WSN_REQ_DATATYPE 2

#define PLAYER_WSN_REQ_DATAFREQ 3



typedef struct player_wsn_node_data
{
  float light;
  float mic;
  float accel_x;
  float accel_y;
  float accel_z;
  float magn_x;
  float magn_y;
  float magn_z;
  float temperature;
  float battery;
} player_wsn_node_data_t;

typedef struct player_wsn_data
{
  uint32_t node_type;
  uint32_t node_id;
  uint32_t node_parent_id;
  player_wsn_node_data_t data_packet;
} player_wsn_data_t;

typedef struct player_wsn_cmd
{
  int32_t node_id;
  int32_t group_id;
  uint32_t device;
  uint8_t enable;
} player_wsn_cmd_t;

typedef struct player_wsn_power_config
{
  int32_t node_id;
  int32_t group_id;
  uint8_t value;
} player_wsn_power_config_t;

typedef struct player_wsn_datatype_config
{
  uint8_t value;
} player_wsn_datatype_config_t;

typedef struct player_wsn_datafreq_config
{
  int32_t node_id;
  int32_t group_id;
  double  frequency;
} player_wsn_datafreq_config_t;

 
#define PLAYER_GRAPHICS3D_CODE 58

#define PLAYER_GRAPHICS3D_STRING "graphics3d" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_GRAPHICS3D_CMD_CLEAR 1

#define PLAYER_GRAPHICS3D_CMD_DRAW 2

#define PLAYER_GRAPHICS3D_CMD_TRANSLATE 3

#define PLAYER_GRAPHICS3D_CMD_ROTATE 4

#define PLAYER_GRAPHICS3D_CMD_PUSH 5

#define PLAYER_GRAPHICS3D_CMD_POP 6



typedef enum player_graphics3d_draw_mode
{
  PLAYER_DRAW_POINTS,
  PLAYER_DRAW_LINES,
  PLAYER_DRAW_LINE_STRIP,
  PLAYER_DRAW_LINE_LOOP,
  PLAYER_DRAW_TRIANGLES,
  PLAYER_DRAW_TRIANGLE_STRIP,
  PLAYER_DRAW_TRIANGLE_FAN,
  PLAYER_DRAW_QUADS,
  PLAYER_DRAW_QUAD_STRIP,
  PLAYER_DRAW_POLYGON
} player_graphics3d_draw_mode_t;


typedef struct player_graphics3d_cmd_draw
{
  uint32_t draw_mode;
  uint32_t points_count;
  player_point_3d_t *points;
  player_color_t color;

} player_graphics3d_cmd_draw_t;

typedef struct player_graphics3d_cmd_translate
{
  double x; 
  double y; 
  double z; 
} player_graphics3d_cmd_translate_t;

typedef struct player_graphics3d_cmd_rotate
{
  double a; 
  double x; 
  double y; 
  double z; 
} player_graphics3d_cmd_rotate_t;


 
#define PLAYER_HEALTH_CODE 59

#define PLAYER_HEALTH_STRING "health" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_HEALTH_DATA_STATE 1


typedef struct player_health_cpu
{
    float idle;
    float system;
    float user;
} player_health_cpu_t;

typedef struct player_health_memory
{
    int64_t total;
    int64_t used;
    int64_t free;
} player_health_memory_t;
typedef struct player_health_data
{
    player_health_cpu_t cpu_usage;
    player_health_memory_t mem;
    player_health_memory_t swap;

} player_health_data_t;

 
#define PLAYER_IMU_CODE 60

#define PLAYER_IMU_STRING "imu" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_IMU_DATA_STATE 1

#define PLAYER_IMU_DATA_CALIB 2

#define PLAYER_IMU_DATA_QUAT 3

#define PLAYER_IMU_DATA_EULER 4

#define PLAYER_IMU_DATA_FULLSTATE 5

#define PLAYER_IMU_REQ_SET_DATATYPE 1

#define PLAYER_IMU_REQ_RESET_ORIENTATION 2




typedef struct player_imu_data_state
{
    player_pose3d_t pose;
} player_imu_data_state_t;

typedef struct player_imu_data_calib
{
    float accel_x;
    float accel_y;
    float accel_z;
    float gyro_x;
    float gyro_y;
    float gyro_z;
    float magn_x;
    float magn_y;
    float magn_z;
} player_imu_data_calib_t;

typedef struct player_imu_data_quat
{
    player_imu_data_calib_t calib_data;

    float q0;
    float q1;
    float q2;
    float q3;
} player_imu_data_quat_t;

typedef struct player_imu_data_euler
{
    player_imu_data_calib_t calib_data;

    player_orientation_3d_t orientation;
} player_imu_data_euler_t;


typedef struct player_imu_data_fullstate
{
    player_pose3d_t pose;
    player_pose3d_t vel;
    player_pose3d_t acc;
} player_imu_data_fullstate_t;




typedef struct player_imu_datatype_config
{
    uint8_t value;
} player_imu_datatype_config_t;

typedef struct player_imu_reset_orientation_config
{
  uint32_t value;
} player_imu_reset_orientation_config_t;

 
#define PLAYER_POINTCLOUD3D_CODE 61

#define PLAYER_POINTCLOUD3D_STRING "pointcloud3d" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_POINTCLOUD3D_DATA_STATE 1



typedef struct player_pointcloud3d_element
{
  player_point_3d_t point;
  player_color_t color;
} player_pointcloud3d_element_t;

typedef struct player_pointcloud3d_data
{
  uint32_t points_count;
  player_pointcloud3d_element_t *points;
} player_pointcloud3d_data_t;


 
#define PLAYER_RANGER_CODE 62

#define PLAYER_RANGER_STRING "ranger" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_RANGER_DATA_RANGE 1

#define PLAYER_RANGER_DATA_RANGESTAMPED 2

#define PLAYER_RANGER_DATA_INTNS 3

#define PLAYER_RANGER_DATA_INTNSSTAMPED 4

#define PLAYER_RANGER_DATA_GEOM 5

#define PLAYER_RANGER_REQ_GET_GEOM 1

#define PLAYER_RANGER_REQ_POWER 2

#define PLAYER_RANGER_REQ_INTNS 3

#define PLAYER_RANGER_REQ_SET_CONFIG 4

#define PLAYER_RANGER_REQ_GET_CONFIG 5



typedef struct player_ranger_config
{
  double min_angle;
  double max_angle;
  double angular_res;
  double min_range;
  double max_range;
  double range_res;
  double frequency;
} player_ranger_config_t;

typedef struct player_ranger_geom
{
  player_pose3d_t pose;
  player_bbox3d_t size;
  uint32_t element_poses_count;
  player_pose3d_t *element_poses;
  uint32_t element_sizes_count;
  player_bbox3d_t *element_sizes;
} player_ranger_geom_t;

typedef struct player_ranger_data_range
{
  uint32_t ranges_count;
  double *ranges;
} player_ranger_data_range_t;

typedef struct player_ranger_data_rangestamped
{
  player_ranger_data_range_t data;
  uint8_t have_geom;
  player_ranger_geom_t geom;
  uint8_t have_config;
  player_ranger_config_t config;
} player_ranger_data_rangestamped_t;

typedef struct player_ranger_data_intns
{
  uint32_t intensities_count;
  double *intensities;
} player_ranger_data_intns_t;

typedef struct player_ranger_data_intnsstamped
{
  player_ranger_data_intns_t data;
  uint8_t have_geom;
  player_ranger_geom_t geom;
  uint8_t have_config;
  player_ranger_config_t config;
} player_ranger_data_intnsstamped_t;

typedef struct player_ranger_power_config
{
  uint8_t state;
} player_ranger_power_config_t;

typedef struct player_ranger_intns_config
{
  uint8_t state;
} player_ranger_intns_config_t;


 
#define PLAYER_VECTORMAP_CODE 63

#define PLAYER_VECTORMAP_STRING "vectormap" 

// /////////////////////////////////////////////////////////////////////////////

#define PLAYER_VECTORMAP_REQ_GET_MAP_INFO 1

#define PLAYER_VECTORMAP_REQ_GET_LAYER_DATA 3

#define PLAYER_VECTORMAP_REQ_WRITE_LAYER 4



typedef struct player_vectormap_feature_data
{
  uint32_t name_count;
  char* name;
  uint32_t wkb_count;
  uint8_t* wkb;

  uint32_t attrib_count;
  char* attrib;
} player_vectormap_feature_data_t;

typedef struct player_vectormap_layer_info
{
  uint32_t name_count;
  char* name;
  player_extent2d_t extent;
} player_vectormap_layer_info_t;

typedef struct player_vectormap_layer_data
{
  uint32_t name_count;
  char* name;
  uint32_t features_count;
  player_vectormap_feature_data_t* features;
} player_vectormap_layer_data_t;

typedef struct player_vectormap_info
{
  uint32_t srid;
  uint32_t layers_count;
  player_vectormap_layer_info_t* layers;
  player_extent2d_t extent;
} player_vectormap_info_t;


 
#define PLAYER_BLACKBOARD_CODE 64

#define PLAYER_BLACKBOARD_STRING "blackboard" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_BLACKBOARD_REQ_SUBSCRIBE_TO_KEY 1

#define PLAYER_BLACKBOARD_REQ_UNSUBSCRIBE_FROM_KEY 2

#define PLAYER_BLACKBOARD_REQ_SET_ENTRY 3

#define PLAYER_BLACKBOARD_REQ_SUBSCRIBE_TO_GROUP 4

#define PLAYER_BLACKBOARD_REQ_UNSUBSCRIBE_FROM_GROUP 5

#define PLAYER_BLACKBOARD_REQ_GET_ENTRY 6

#define PLAYER_BLACKBOARD_DATA_UPDATE 1




 
#define PLAYER_STEREO_CODE 65

#define PLAYER_STEREO_STRING "stereo" 

// /////////////////////////////////////////////////////////////////////////////
#define PLAYER_STEREO_DATA_STATE 1


typedef struct player_pointcloud3d_stereo_element
{
  float px;
  float py;
  float pz;
  uint8_t red;
  uint8_t green;
  uint8_t blue;
} player_pointcloud3d_stereo_element_t;

typedef struct player_stereo_data
{
  /* Left channel image */
  player_camera_data_t left_channel;
  /* Right channel image */
  player_camera_data_t right_channel;

  /* Disparity image */
  player_camera_data_t disparity;
  
  /* 3-D stereo point cloud */
  uint32_t points_count;
  player_pointcloud3d_stereo_element_t *points;


  /* Special mode flags: define what images are being sent */
  uint32_t mode;
} player_stereo_data_t;

 
/* END OF AUTOGENERATED CODE */