sr_robot_lib.cpp
Go to the documentation of this file.
1 
27 #include <string>
28 #include <utility>
29 #include <map>
30 #include <vector>
31 #include <boost/foreach.hpp>
32 
33 #include <sys/time.h>
34 
35 #include <ros/ros.h>
36 
38 #include "sr_robot_lib/biotac.hpp"
39 #include "sr_robot_lib/UBI0.hpp"
40 #include <controller_manager_msgs/ListControllers.h>
42 
43 #define SERIOUS_ERROR_FLAGS PALM_0200_EDC_SERIOUS_ERROR_FLAGS
44 #define error_flag_names palm_0200_edc_error_flag_names
45 
46 using std::vector;
47 using std::string;
48 using std::pair;
49 using std::map;
50 using std::ostringstream;
51 using sr_actuator::SrMotorActuator;
54 using tactiles::Biotac;
55 using tactiles::UBI0;
65 using boost::shared_ptr;
66 using boost::ptr_vector;
67 
68 
69 namespace shadow_robot
70 {
71 #ifdef DEBUG_PUBLISHER
72  // max of 20 publishers for debug
73  template<class StatusType, class CommandType>
74  const int SrRobotLib<StatusType, CommandType>::nb_debug_publishers_const = 20;
75  // template <class StatusType, class CommandType>
76  // const int SrRobotLib<StatusType, CommandType>::debug_mutex_lock_wait_time = 100;
77 #endif
78 
79  template <class StatusType, class CommandType>
81 
82  template <class StatusType, class CommandType>
84  {
85  "TACTILE_SENSOR_TYPE_SAMPLE_FREQUENCY_HZ",
86  "TACTILE_SENSOR_TYPE_MANUFACTURER",
87  "TACTILE_SENSOR_TYPE_SERIAL_NUMBER",
88  "TACTILE_SENSOR_TYPE_SOFTWARE_VERSION",
89  "TACTILE_SENSOR_TYPE_PCB_VERSION",
90  "TACTILE_SENSOR_TYPE_WHICH_SENSORS",
91  "TACTILE_SENSOR_TYPE_PST3_PRESSURE_TEMPERATURE",
92  "TACTILE_SENSOR_TYPE_PST3_PRESSURE_RAW_ZERO_TRACKING",
93  "TACTILE_SENSOR_TYPE_PST3_DAC_VALUE",
94  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_1",
95  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_2",
96  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_3",
97  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_4",
98  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_5",
99  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_6",
100  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_7",
101  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_8",
102  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_9",
103  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_10",
104  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_11",
105  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_12",
106  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_13",
107  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_14",
108  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_15",
109  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_16",
110  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_17",
111  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_18",
112  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_19",
113  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_20",
114  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_21",
115  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_22",
116  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_23",
117  "TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_24",
118  "TACTILE_SENSOR_TYPE_BIOTAC_PDC",
119  "TACTILE_SENSOR_TYPE_BIOTAC_TAC",
120  "TACTILE_SENSOR_TYPE_BIOTAC_TDC",
121  "TACTILE_SENSOR_TYPE_UBI0_TACTILE"
122  };
123 
124  template <class StatusType, class CommandType>
126  {
164  };
165 
166  template<class StatusType, class CommandType>
168 
169  template<class StatusType, class CommandType>
170  SrRobotLib<StatusType, CommandType>::SrRobotLib(hardware_interface::HardwareInterface *hw, ros::NodeHandle nh,
171  ros::NodeHandle nhtilde, string device_id, string joint_prefix)
172  : main_pic_idle_time(0),
173  main_pic_idle_time_min(1000),
174  tactile_current_state(operation_mode::device_update_state::INITIALIZATION),
175  hw_(static_cast<RobotState *> (hw)),
176  device_id_(device_id),
177  joint_prefix_(joint_prefix),
178  nullify_demand_(false),
179  nodehandle_(nh),
180  nh_tilde(nhtilde),
181 
182  // advertise the service to nullify the demand sent to the motor
183  // this makes it possible to easily stop the controllers.
184  nullify_demand_server_(
185  nh_tilde.advertiseService("nullify_demand", &SrRobotLib::nullify_demand_callback, this)),
186 
187  // initialises self tests (false as this is not a simulated hand\)
188  // self_tests_(new SrSelfTest(false)),
189  // self_test_thread_(new boost::thread(boost::bind(&SrRobotLib::checkSelfTests, this))),
190 
191  // read the generic sensor polling frequency from the parameter server
192  generic_sensor_update_rate_configs_vector(
193  read_update_rate_configs("generic_sensor_data_update_rate/", nb_sensor_data,
194  human_readable_sensor_data_types, sensor_data_types)),
195 
196  // read the pst3 sensor polling frequency from the parameter server
197  pst3_sensor_update_rate_configs_vector(
198  read_update_rate_configs("pst3_sensor_data_update_rate/", nb_sensor_data,
199  human_readable_sensor_data_types, sensor_data_types)),
200 
201  // read the biotac sensor polling frequency from the parameter server
202  biotac_sensor_update_rate_configs_vector(
203  read_update_rate_configs("biotac_sensor_data_update_rate/", nb_sensor_data,
204  human_readable_sensor_data_types, sensor_data_types)),
205 
206  // read the UBI0 sensor polling frequency from the parameter server
207  ubi0_sensor_update_rate_configs_vector(
208  read_update_rate_configs("ubi0_sensor_data_update_rate/", nb_sensor_data,
209  human_readable_sensor_data_types, sensor_data_types)),
210 
211  tactile_init_max_duration(tactile_timeout),
212 
213  // Create a one-shot timer
214  tactile_check_init_timeout_timer(
215  this->nh_tilde.createTimer(tactile_init_max_duration,
216  boost::bind(
217  &SrRobotLib<StatusType,
218  CommandType>::tactile_init_timer_callback,
219  this, _1), true)),
220  lock_tactile_init_timeout_(boost::shared_ptr<boost::mutex>(new boost::mutex())),
221  tactiles_init(shared_ptr<GenericTactiles<StatusType, CommandType> >(
222  new GenericTactiles<StatusType, CommandType>(nodehandle_, device_id_,
223  generic_sensor_update_rate_configs_vector,
224  operation_mode::device_update_state::INITIALIZATION))),
225 
226  // initialize the calibration map
227  calibration_map(read_joint_calibration()),
228  // initialize the coupled joints calibration map
229  coupled_calibration_map(read_coupled_joint_calibration())
230  {
231  std::vector<std::string> calibration_map_keys = calibration_map.keys();
232  for (auto & coupled_calibration : coupled_calibration_map)
233  {
234  if (std::find(calibration_map_keys.begin(),
235  calibration_map_keys.end(), coupled_calibration.first)
236  != calibration_map_keys.end())
237  {
238  ROS_WARN_STREAM("Calibration for joint " << coupled_calibration.first << " present in both regular and "
239  "coupled form in the calibration file. Only coupled calibration will be used!");
240  }
241  }
242  }
243 
244  template<class StatusType, class CommandType>
246  {
247  // Create a new GenericTactiles object
249  new GenericTactiles<StatusType, CommandType>(nodehandle_, device_id_,
250  generic_sensor_update_rate_configs_vector,
253  }
254 
255  template<class StatusType, class CommandType>
256  bool SrRobotLib<StatusType, CommandType>::nullify_demand_callback(sr_robot_msgs::NullifyDemand::Request &request,
257  sr_robot_msgs::NullifyDemand::Response &response)
258  {
259  if (request.nullify_demand)
261  "Nullifying the demand sent to the motor. "
262  "Will ignore the values computed by the controllers and send 0.");
263  else
264  ROS_INFO_STREAM("Using the value computed by the controllers to send the demands to the motors.");
265 
266  nullify_demand_ = request.nullify_demand;
267  return true;
268  }
269 
270  template<class StatusType, class CommandType>
272  {
273  // Mutual exclusion with the the initialization timeout
274  boost::mutex::scoped_lock l(*lock_tactile_init_timeout_);
275 
276  if (tactile_current_state == operation_mode::device_update_state::INITIALIZATION)
277  {
278  if (tactiles_init->sensor_updater->build_init_command(command)
280  {
281  tactile_current_state = operation_mode::device_update_state::OPERATION;
282 
283  tactile_check_init_timeout_timer.stop();
284 
285  switch (tactiles_init->tactiles_vector->at(0).which_sensor)
286  {
289  new ShadowPSTs<StatusType, CommandType>(nodehandle_, device_id_,
290  pst3_sensor_update_rate_configs_vector,
292  tactiles_init->tactiles_vector));
293 
294  ROS_INFO("PST3 tactiles initialized");
295  break;
296 
299  new Biotac<StatusType, CommandType>(nodehandle_, device_id_,
300  biotac_sensor_update_rate_configs_vector,
302  tactiles_init->tactiles_vector));
303 
304  ROS_INFO("Biotac tactiles initialized");
305  break;
306 
309  new UBI0<StatusType, CommandType>(nodehandle_, device_id_, ubi0_sensor_update_rate_configs_vector,
311  tactiles_init->tactiles_vector));
312 
313  ROS_INFO("UBI0 tactiles initialized");
314  break;
315 
317  ROS_WARN_STREAM("TACTILE_SENSOR_PROTOCOL_TYPE_INVALID!!");
318  break;
320  ROS_WARN_STREAM("TACTILE_SENSOR_PROTOCOL_TYPE_CONFLICTING!!");
321  break;
322  }
323  }
324  }
325  else
326  {
327  tactile_current_state = tactiles->sensor_updater->build_command(command);
328  }
329  }
330 
331  template<class StatusType, class CommandType>
333  {
334  // Mutual exclusion with the the initialization timeout
335  boost::mutex::scoped_lock l(*lock_tactile_init_timeout_);
336  if (tactile_current_state == operation_mode::device_update_state::INITIALIZATION)
337  {
338  if (tactiles_init != NULL)
339  {
340  tactiles_init->update(status);
341  }
342  }
343  else
344  {
345  if (tactiles != NULL)
346  {
347  tactiles->update(status);
348  }
349  }
350  }
351 
352  template<class StatusType, class CommandType>
354  {
355  CalibrationMap joint_calibration;
356 
357  XmlRpc::XmlRpcValue calib;
358  nodehandle_.getParam("sr_calibrations", calib);
360  // iterate on all the joints
361  for (int32_t index_cal = 0; index_cal < calib.size(); ++index_cal)
362  {
363  // check the calibration is well formatted:
364  // first joint name, then calibration table
365  ROS_ASSERT(calib[index_cal][0].getType() == XmlRpc::XmlRpcValue::TypeString);
366  ROS_ASSERT(calib[index_cal][1].getType() == XmlRpc::XmlRpcValue::TypeArray);
367 
368  string joint_name = static_cast<string> (calib[index_cal][0]);
369  vector<joint_calibration::Point> calib_table_tmp;
370 
371  // now iterates on the calibration table for the current joint
372  for (int32_t index_table = 0; index_table < calib[index_cal][1].size(); ++index_table)
373  {
374  ROS_ASSERT(calib[index_cal][1][index_table].getType() == XmlRpc::XmlRpcValue::TypeArray);
375  // only 2 values per calibration point: raw and calibrated (doubles)
376  ROS_ASSERT(calib[index_cal][1][index_table].size() == 2);
377  ROS_ASSERT(calib[index_cal][1][index_table][0].getType() == XmlRpc::XmlRpcValue::TypeDouble);
378  ROS_ASSERT(calib[index_cal][1][index_table][1].getType() == XmlRpc::XmlRpcValue::TypeDouble);
379 
380  joint_calibration::Point point_tmp;
381  point_tmp.raw_value = static_cast<double> (calib[index_cal][1][index_table][0]);
382  point_tmp.calibrated_value = sr_math_utils::to_rad(static_cast<double> (calib[index_cal][1][index_table][1]));
383  calib_table_tmp.push_back(point_tmp);
384  }
385 
386  joint_calibration.insert(joint_name, shared_ptr<shadow_robot::JointCalibration>(
387  new shadow_robot::JointCalibration(calib_table_tmp)));
388  }
389 
390  return joint_calibration;
391  } // end read_joint_calibration
392 
393  template<class StatusType, class CommandType>
396  {
397  CoupledJointMapType coupled_joint_calibration;
398  XmlRpc::XmlRpcValue calib;
399  nodehandle_.getParam("sr_calibrations_coupled", calib);
400  if (!calib.valid())
401  {
402  ROS_WARN("No coupled calibration specified.");
403  return coupled_joint_calibration;
404  }
405 
407  // iterate on all the joint pairs
408  for (int32_t cal_index = 0; cal_index < calib.size(); ++cal_index)
409  {
410  std::vector<std::string> joint_pair;
411  std::vector<double> raw_values_coupled_0, raw_values_coupled_1, calibrated_values_0, calibrated_values_1;
412 
413  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeArray == calib[cal_index][0].getType());
414  ROS_ASSERT(2 == calib[cal_index][0].size());
415  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeArray == calib[cal_index][1].getType());
416 
417  // check if values format is ok
418  for (int32_t raw_and_calibrated_value_index = 0;
419  raw_and_calibrated_value_index < calib[cal_index][1].size();
420  ++raw_and_calibrated_value_index)
421  {
422  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeArray == calib[cal_index][1][raw_and_calibrated_value_index].getType());
423  ROS_ASSERT(3 == calib[cal_index][1][raw_and_calibrated_value_index].size());
424 
425  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeArray == calib[cal_index][1][raw_and_calibrated_value_index][0].getType());
426  ROS_ASSERT(2 == calib[cal_index][1][raw_and_calibrated_value_index][0].size());
428  calib[cal_index][1][raw_and_calibrated_value_index][0][0].getType());
430  calib[cal_index][1][raw_and_calibrated_value_index][0][1].getType());
432  calib[cal_index][1][raw_and_calibrated_value_index][1].getType());
434  calib[cal_index][1][raw_and_calibrated_value_index][2].getType());
435 
436  raw_values_coupled_0.push_back(static_cast<double>(calib[cal_index][1][raw_and_calibrated_value_index][0][0]));
437  raw_values_coupled_0.push_back(static_cast<double>(calib[cal_index][1][raw_and_calibrated_value_index][0][1]));
438  raw_values_coupled_1.push_back(static_cast<double>(calib[cal_index][1][raw_and_calibrated_value_index][0][1]));
439  raw_values_coupled_1.push_back(static_cast<double>(calib[cal_index][1][raw_and_calibrated_value_index][0][0]));
440  calibrated_values_0.push_back(sr_math_utils::to_rad(static_cast<double>
441  (calib[cal_index][1][raw_and_calibrated_value_index][1])));
442  calibrated_values_1.push_back(sr_math_utils::to_rad(static_cast<double>
443  (calib[cal_index][1][raw_and_calibrated_value_index][2])));
444  } // value format ok
445 
446  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeString == calib[cal_index][0][0].getType());
447  ROS_ASSERT(XmlRpc::XmlRpcValue::TypeString == calib[cal_index][0][1].getType());
448 
449  std::string joint_0_name = static_cast<string>(calib[cal_index][0][0]);
450  std::string joint_1_name = static_cast<string>(calib[cal_index][0][1]);
451 
452  CoupledJoint coupled_joint_0(joint_0_name, joint_1_name, raw_values_coupled_0, calibrated_values_0);
453  CoupledJoint coupled_joint_1(joint_1_name, joint_0_name, raw_values_coupled_1, calibrated_values_1);
454 
455  coupled_joint_calibration.insert(std::pair<std::string, CoupledJoint>(joint_0_name, coupled_joint_0));
456  coupled_joint_calibration.insert(std::pair<std::string, CoupledJoint>(joint_1_name, coupled_joint_1));
457  }
458  return coupled_joint_calibration;
459  } // end read_coupled_joint_calibration
460 
461  template<class StatusType, class CommandType>
463  {
464  vector<JointToSensor> joint_to_sensor_vect;
465 
466  map<string, int> sensors_map;
467  for (unsigned int i = 0; i < SENSORS_NUM_0220; ++i)
468  {
469  sensors_map[sensor_names[i]] = i;
470  }
471 
472  XmlRpc::XmlRpcValue joint_to_sensor_mapping;
473  nodehandle_.getParam("joint_to_sensor_mapping", joint_to_sensor_mapping);
474  ROS_ASSERT(joint_to_sensor_mapping.getType() == XmlRpc::XmlRpcValue::TypeArray);
475  for (int32_t i = 0; i < joint_to_sensor_mapping.size(); ++i)
476  {
477  JointToSensor tmp_vect;
478 
479  XmlRpc::XmlRpcValue map_one_joint = joint_to_sensor_mapping[i];
480 
481  // The parameter can either start by an array (sensor_name, coeff)
482  // or by an integer to specify if we calibrate before combining
483  // the different sensors
484  int param_index = 0;
485  // Check if the calibrate after combine int is set to 1
486  if (map_one_joint[param_index].getType() == XmlRpc::XmlRpcValue::TypeInt)
487  {
488  if (1 == static_cast<int> (map_one_joint[0]))
489  {
490  tmp_vect.calibrate_after_combining_sensors = true;
491  }
492  else
493  {
494  tmp_vect.calibrate_after_combining_sensors = false;
495  }
496 
497  param_index++;
498  }
499  else
500  {
501  // by default we calibrate before combining the sensors
502  tmp_vect.calibrate_after_combining_sensors = false;
503  }
504 
506  for (int32_t i = param_index; i < map_one_joint.size(); ++i)
507  {
508  ROS_ASSERT(map_one_joint[i].getType() == XmlRpc::XmlRpcValue::TypeArray);
509  PartialJointToSensor tmp_joint_to_sensor;
510 
511  ROS_ASSERT(map_one_joint[i][0].getType() == XmlRpc::XmlRpcValue::TypeString);
512  tmp_vect.sensor_names.push_back(static_cast<string> (map_one_joint[i][0]));
513  tmp_joint_to_sensor.sensor_id = sensors_map[static_cast<string> (map_one_joint[i][0])];
514 
515  ROS_ASSERT(map_one_joint[i][1].getType() == XmlRpc::XmlRpcValue::TypeDouble);
516  tmp_joint_to_sensor.coeff = static_cast<double> (map_one_joint[i][1]);
517  tmp_vect.joint_to_sensor_vector.push_back(tmp_joint_to_sensor);
518  }
519  joint_to_sensor_vect.push_back(tmp_vect);
520  }
521 
522  return joint_to_sensor_vect;
523  } // end read_joint_to_sensor_mapping
524 
525  template<class StatusType, class CommandType>
526  vector<UpdateConfig> SrRobotLib<StatusType,
527  CommandType>::read_update_rate_configs(string base_param,
528  int nb_data_defined,
529  const char *human_readable_data_types[],
530  const int32u data_types[])
531  {
532  vector<UpdateConfig> update_rate_configs_vector;
533  typedef pair<string, int32u> ConfPair;
534  vector<ConfPair> config;
535 
536  for (int i = 0; i < nb_data_defined; ++i)
537  {
538  ConfPair tmp;
539 
540  ROS_DEBUG_STREAM(" read " << base_param << " config [" << i << "] = " << human_readable_data_types[i]);
541 
542  tmp.first = base_param + human_readable_data_types[i];
543  tmp.second = data_types[i];
544  config.push_back(tmp);
545  }
546 
547  for (unsigned int i = 0; i < config.size(); ++i)
548  {
549  double rate;
550  if (nodehandle_.getParam(config[i].first, rate))
551  {
552  UpdateConfig config_tmp;
553 
554  config_tmp.when_to_update = rate;
555  config_tmp.what_to_update = config[i].second;
556  update_rate_configs_vector.push_back(config_tmp);
557 
559  " read " << base_param << " config [" << i << "] = " << "what: " << config_tmp.what_to_update <<
560  " when: " << config_tmp.when_to_update);
561  }
562  }
563 
564  return update_rate_configs_vector;
565  }
566 
567  template<class StatusType, class CommandType>
569  {
570  // Mutual exclusion with the the initialization timeout
571  boost::mutex::scoped_lock l(*lock_tactile_init_timeout_);
572 
573  if (tactile_current_state == operation_mode::device_update_state::INITIALIZATION)
574  {
575  tactile_current_state = operation_mode::device_update_state::OPERATION;
577  new tactiles::UBI0<StatusType, CommandType>(nodehandle_, device_id_,
578  ubi0_sensor_update_rate_configs_vector,
580  tactiles_init->tactiles_vector));
581  ROS_WARN_STREAM("Tactile Initialization Timeout: considering UBI0 tactiles");
582  }
583  }
584 
585  CoupledJoint::CoupledJoint(std::string joint_name, std::string joint_sibling_name,
586  std::vector<double> raw_values_coupled_vector,
587  std::vector<double> calibrated_values_vector)
588  {
589  name_ = joint_name;
590  sibling_name_ = joint_sibling_name;
591 
592  calibration_points_ = raw_values_coupled_vector.size() / 2;
593  total_points_ = calibration_points_ + nb_surrounding_points_;
594 
595  for (int i = 0; i < 2*total_points_; i++)
596  {
597  raw_values_coupled_.push_back(0);
598  }
599 
600  for (int i = 0; i < total_points_; i++)
601  {
602  calibrated_values_.push_back(0);
603  }
604 
605  for (int i = 0; i < 3*2*total_points_; i++)
606  {
607  triangle_.push_back(0);
608  element_neighbor_.push_back(0);
609  }
610 
611  for (std::vector<double>::size_type i = 0; i != raw_values_coupled_vector.size(); i++)
612  {
613  raw_values_coupled_[i] = raw_values_coupled_vector[i];
614  }
615 
616  for (std::vector<double>::size_type i = 0; i != calibrated_values_vector.size(); i++)
617  {
618  calibrated_values_[i] = calibrated_values_vector[i];
619  }
620 
621  process_calibration_values();
622  }
623 
624  CoupledJoint::~CoupledJoint()
625  {
626  }
627 
628  void CoupledJoint::process_calibration_values()
629  {
630  // Generate additional points around the actual calibration points
631  add_surrounding_points(calibration_points_, &raw_values_coupled_[0],
632  &calibrated_values_[0], nb_surrounding_points_);
633  //
634  // Set up the Delaunay triangulation.
635  //
636  r8tris2(total_points_, &raw_values_coupled_[0], element_num_, &triangle_[0], &element_neighbor_[0]);
637 
638  for (int j = 0; j < element_num_; j++)
639  {
640  for (int i = 0; i < 3; i++)
641  {
642  if ( 0 < element_neighbor_[i+j*3] )
643  {
644  element_neighbor_[i+j*3] = element_neighbor_[i+j*3] - 1;
645  }
646  }
647  }
648  }
649 
650 // Only to ensure that the template class is compiled for the types we are interested in
651  template
653 
654  template
656 
657  template
659 
660  template
662 
663 } // namespace shadow_robot
664 
665 /* For the emacs weenies in the crowd.
666  Local Variables:
667  c-basic-offset: 2
668  End:
669 */
TACTILE_SENSOR_PROTOCOL_TYPE_CONFLICTING
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_20
TACTILE_SENSOR_TYPE_PST3_PRESSURE_TEMPERATURE
std::map< std::string, CoupledJoint > CoupledJointMapType
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_9
TACTILE_SENSOR_TYPE_SOFTWARE_VERSION
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_15
SrRobotLib(hardware_interface::HardwareInterface *hw, ros::NodeHandle nh, ros::NodeHandle nhtilde, std::string device_id, std::string joint_prefix)
TACTILE_SENSOR_PROTOCOL_TYPE_BIOTAC_2_3
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_4
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_1
TACTILE_SENSOR_TYPE_BIOTAC_TDC
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_22
TACTILE_SENSOR_TYPE_MANUFACTURER
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_18
static const double tactile_timeout
Timeout handling variables for UBI sensors.
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_5
std::vector< std::string > sensor_names
TACTILE_SENSOR_TYPE_BIOTAC_PDC
static const int32u sensor_data_types[]
TACTILE_SENSOR_TYPE_PST3_DAC_VALUE
TACTILE_SENSOR_TYPE_BIOTAC_TAC
ServiceServer advertiseService(ros::NodeHandle n, std::string name, boost::function< bool(const typename ActionSpec::_action_goal_type::_goal_type &, typename ActionSpec::_action_result_type::_result_type &result)> service_cb)
bool valid() const
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_10
TACTILE_SENSOR_TYPE_UBI0_TACTILE
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_19
#define ROS_WARN(...)
unsigned int int32u
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_3
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_8
TACTILE_SENSOR_PROTOCOL_TYPE_INVALID
Type const & getType() const
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_13
std::vector< PartialJointToSensor > joint_to_sensor_vector
static const char * human_readable_sensor_data_types[]
TACTILE_SENSOR_TYPE_SERIAL_NUMBER
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_6
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_17
#define ROS_INFO(...)
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_11
TACTILE_SENSOR_TYPE_PST3_PRESSURE_RAW_ZERO_TRACKING
TACTILE_SENSOR_TYPE_PCB_VERSION
static const int nb_sensor_data
#define ROS_WARN_STREAM(args)
#define ROS_DEBUG_STREAM(args)
TACTILE_SENSOR_PROTOCOL_TYPE_PST3
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_14
TACTILE_SENSOR_TYPE_WHICH_SENSORS
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_24
TACTILE_SENSOR_TYPE_SAMPLE_FREQUENCY_HZ
#define ROS_INFO_STREAM(args)
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_21
TACTILE_SENSOR_PROTOCOL_TYPE_UBI0
threadsafe::Map< boost::shared_ptr< shadow_robot::JointCalibration > > CalibrationMap
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_12
#define ROS_ASSERT(cond)
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_2
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_7
#define SENSORS_NUM_0220
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_23
TACTILE_SENSOR_TYPE_BIOTAC_ELECTRODE_16


sr_robot_lib
Author(s): Ugo Cupcic, Toni Oliver
autogenerated on Mon Feb 28 2022 23:50:43