HEBI C++ API  3.4.0
info.hpp
Go to the documentation of this file.
1 #pragma once
2 
3 #include "hebi.h"
4 
5 #include <string>
6 
7 #include "color.hpp"
8 #include "gains.hpp"
9 #include "message_helpers.hpp"
10 #include "util.hpp"
11 
12 namespace hebi {
13 
33 class Info final {
34 public:
35  enum class ControlStrategy {
37  Off,
39  DirectPWM,
42  Strategy2,
45  Strategy3,
48  Strategy4,
49  };
50 
51  enum class CalibrationState {
53  Normal,
60  };
61 
62  enum class MstopStrategy {
64  Disabled,
66  MotorOff,
69  };
70 
71  enum class PositionLimitStrategy {
77  MotorOff,
79  Disabled,
80  };
81 
82 protected:
84  class FloatField final {
85  public:
86 #ifndef DOXYGEN_OMIT_INTERNAL
87  FloatField(const HebiInfoRef& internal, HebiInfoFloatField field);
88 #endif // DOXYGEN_OMIT_INTERNAL
89  explicit operator bool() const { return has(); }
103  bool has() const;
106  float get() const;
107 
109  private:
110  const HebiInfoRef& internal_;
111  HebiInfoFloatField const field_;
112  };
113 
119  class HighResAngleField final {
120  public:
121 #ifndef DOXYGEN_OMIT_INTERNAL
122  HighResAngleField(const HebiInfoRef& internal, HebiInfoHighResAngleField field);
123 #endif // DOXYGEN_OMIT_INTERNAL
124  explicit operator bool() const { return has(); }
138  bool has() const;
144  double get() const;
156  void get(int64_t* revolutions, float* radian_offset) const;
157 
159  private:
160  const HebiInfoRef& internal_;
161  HebiInfoHighResAngleField const field_;
162  };
163 
165  class BoolField final {
166  public:
167 #ifndef DOXYGEN_OMIT_INTERNAL
168  BoolField(const HebiInfoRef& internal, HebiInfoBoolField field);
169 #endif // DOXYGEN_OMIT_INTERNAL
170  bool has() const;
174  bool get() const;
175 
177  private:
178  const HebiInfoRef& internal_;
179  HebiInfoBoolField const field_;
180  };
181 
183  class StringField final {
184  public:
185 #ifndef DOXYGEN_OMIT_INTERNAL
186  StringField(HebiInfoPtr internal, HebiInfoStringField field);
187 #endif // DOXYGEN_OMIT_INTERNAL
188  explicit operator bool() const { return has(); }
202  bool has() const;
205  std::string get() const;
206 
208  private:
209  HebiInfoPtr const internal_;
210  HebiInfoStringField const field_;
211  };
212 
214  class FlagField final {
215  public:
216 #ifndef DOXYGEN_OMIT_INTERNAL
217  FlagField(const HebiInfoRef& internal, HebiInfoFlagField field);
218 #endif // DOXYGEN_OMIT_INTERNAL
219  explicit operator bool() const { return has(); }
233  bool has() const;
234 
236  private:
237  const HebiInfoRef& internal_;
238  HebiInfoFlagField const field_;
239  };
240 
242  template<typename T>
243  class EnumField final {
244  public:
245 #ifndef DOXYGEN_OMIT_INTERNAL
246  EnumField(const HebiInfoRef& internal, HebiInfoEnumField field) : internal_(internal), field_(field) {}
247 #endif // DOXYGEN_OMIT_INTERNAL
248  explicit operator bool() const { return has(); }
262  bool has() const {
263  return (enumGetter(internal_, field_, nullptr) == HebiStatusSuccess);
264  }
267  T get() const {
268  int32_t ret{};
269  enumGetter(internal_, field_, &ret);
270  return static_cast<T>(ret);
271  }
272 
274  private:
275  const HebiInfoRef& internal_;
276  HebiInfoEnumField const field_;
277  };
278 
280  class LedField final {
281  public:
282 #ifndef DOXYGEN_OMIT_INTERNAL
283  LedField(const HebiInfoRef& internal, HebiInfoLedField field);
284 #endif // DOXYGEN_OMIT_INTERNAL
285  explicit operator bool() const { return hasColor(); }
299  bool hasColor() const;
301  Color getColor() const;
302 
304  private:
305  const HebiInfoRef& internal_;
306  HebiInfoLedField const field_;
307  };
308 
310 
312  class Settings final {
313  protected:
315  class Actuator final {
316  public:
317 #ifndef DOXYGEN_OMIT_INTERNAL
318  Actuator(const HebiInfoRef& internal)
319  : position_gains_(internal, HebiInfoFloatPositionKp, HebiInfoBoolPositionDOnError),
320  velocity_gains_(internal, HebiInfoFloatVelocityKp, HebiInfoBoolVelocityDOnError),
321  effort_gains_(internal, HebiInfoFloatEffortKp, HebiInfoBoolEffortDOnError),
322  spring_constant_(internal, HebiInfoFloatSpringConstant),
323  velocity_limit_min_(internal, HebiInfoFloatVelocityLimitMin),
324  velocity_limit_max_(internal, HebiInfoFloatVelocityLimitMax),
325  effort_limit_min_(internal, HebiInfoFloatEffortLimitMin),
326  effort_limit_max_(internal, HebiInfoFloatEffortLimitMax),
327  position_limit_min_(internal, HebiInfoHighResAnglePositionLimitMin),
328  position_limit_max_(internal, HebiInfoHighResAnglePositionLimitMax),
329  control_strategy_(internal, HebiInfoEnumControlStrategy),
330  mstop_strategy_(internal, HebiInfoEnumMstopStrategy),
331  min_position_limit_strategy_(internal, HebiInfoEnumMinPositionLimitStrategy),
332  max_position_limit_strategy_(internal, HebiInfoEnumMaxPositionLimitStrategy) {}
333 #endif // DOXYGEN_OMIT_INTERNAL
334 
335  // With all submessage and field getters: Note that the returned reference
336  // should not be used after the lifetime of this parent.
337 
338  // Submessages ----------------
339 
341  const InfoGains& positionGains() const { return position_gains_; }
343  const InfoGains& velocityGains() const { return velocity_gains_; }
345  const InfoGains& effortGains() const { return effort_gains_; }
346 
347  // Subfields ----------------
348 
350  const FloatField& springConstant() const { return spring_constant_; }
352  const FloatField& velocityLimitMin() const { return velocity_limit_min_; }
354  const FloatField& velocityLimitMax() const { return velocity_limit_max_; }
356  const FloatField& effortLimitMin() const { return effort_limit_min_; }
358  const FloatField& effortLimitMax() const { return effort_limit_max_; }
360  const HighResAngleField& positionLimitMin() const { return position_limit_min_; }
362  const HighResAngleField& positionLimitMax() const { return position_limit_max_; }
364  const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
366  const EnumField<MstopStrategy>& mstopStrategy() const { return mstop_strategy_; }
368  const EnumField<PositionLimitStrategy>& minPositionLimitStrategy() const { return min_position_limit_strategy_; }
370  const EnumField<PositionLimitStrategy>& maxPositionLimitStrategy() const { return max_position_limit_strategy_; }
371 
373  private:
374  InfoGains position_gains_;
375  InfoGains velocity_gains_;
376  InfoGains effort_gains_;
377 
378  FloatField spring_constant_;
379  FloatField velocity_limit_min_;
380  FloatField velocity_limit_max_;
381  FloatField effort_limit_min_;
382  FloatField effort_limit_max_;
383  HighResAngleField position_limit_min_;
384  HighResAngleField position_limit_max_;
385  EnumField<ControlStrategy> control_strategy_;
386  EnumField<MstopStrategy> mstop_strategy_;
387  EnumField<PositionLimitStrategy> min_position_limit_strategy_;
388  EnumField<PositionLimitStrategy> max_position_limit_strategy_;
389  };
390 
392  class Imu final {
393  public:
394 #ifndef DOXYGEN_OMIT_INTERNAL
395  Imu(const HebiInfoRef& internal)
396  : accel_includes_gravity_(internal, HebiInfoBoolAccelIncludesGravity) {}
397 #endif // DOXYGEN_OMIT_INTERNAL
398 
399  // With all submessage and field getters: Note that the returned reference
400  // should not be used after the lifetime of this parent.
401 
402  // Subfields ----------------
403 
405  const BoolField& accelIncludesGravity() const { return accel_includes_gravity_; }
406 
408  private:
409  BoolField accel_includes_gravity_;
410  };
411 
412  public:
413 #ifndef DOXYGEN_OMIT_INTERNAL
414  Settings(HebiInfoPtr internal_ptr, const HebiInfoRef& internal)
415  : actuator_(internal),
416  imu_(internal),
417  name_(internal_ptr, HebiInfoStringName),
418  family_(internal_ptr, HebiInfoStringFamily),
419  save_current_settings_(internal, HebiInfoFlagSaveCurrentSettings) {}
420 #endif // DOXYGEN_OMIT_INTERNAL
421 
422  // With all submessage and field getters: Note that the returned reference
423  // should not be used after the lifetime of this parent.
424 
425  // Submessages ----------------
426 
428  const Actuator& actuator() const { return actuator_; }
430  const Imu& imu() const { return imu_; }
431 
432  // Subfields ----------------
433 
435  const StringField& name() const { return name_; }
437  const StringField& family() const { return family_; }
439  const FlagField& saveCurrentSettings() const { return save_current_settings_; }
440 
442  private:
443  Actuator actuator_;
444  Imu imu_;
445 
446  StringField name_;
447  StringField family_;
448  FlagField save_current_settings_;
449  };
450 
452  class Actuator final {
453  public:
454 #ifndef DOXYGEN_OMIT_INTERNAL
455  Actuator(const HebiInfoRef& internal) : calibration_state_(internal, HebiInfoEnumCalibrationState) {}
456 #endif // DOXYGEN_OMIT_INTERNAL
457 
458  // With all submessage and field getters: Note that the returned reference
459  // should not be used after the lifetime of this parent.
460 
461  // Subfields ----------------
462 
464  const EnumField<CalibrationState>& calibrationState() const { return calibration_state_; }
465 
467  private:
468  EnumField<CalibrationState> calibration_state_;
469  };
470 
471 private:
476  HebiInfoPtr internal_;
477  HebiInfoRef internal_ref_;
478 
479 public:
480 #ifndef DOXYGEN_OMIT_INTERNAL
481 
485  Info(HebiInfoPtr);
486 #endif // DOXYGEN_OMIT_INTERNAL
487 
490  Info(Info&& other);
491 
492  // With all submessage and field getters: Note that the returned reference
493  // should not be used after the lifetime of this parent.
494 
495  // Submessages -------------------------------------------------------------
496 
498  const Settings& settings() const { return settings_; }
500  const Actuator& actuator() const { return actuator_; }
501 
502  // Subfields -------------------------------------------------------------
503 
505  const StringField& serial() const { return serial_; }
507  const LedField& led() const { return led_; }
508 
513 
514  /* Disable move assigment operator. */
515  Info& operator=(Info&& other) = delete;
516 
517 private:
518  Settings settings_;
519  Actuator actuator_;
520 
521  StringField serial_;
522  LedField led_;
523 };
524 
525 } // namespace hebi
const FlagField & saveCurrentSettings() const
Indicates if the module should save the current values of all of its settings.
Definition: info.hpp:439
std::string get() const
If the field has a value, returns a copy of that value; otherwise, returns a default.
Definition: info.cpp:58
const HighResAngleField & positionLimitMin() const
The firmware safety limit for the minimum allowed position.
Definition: info.hpp:360
Module settings that are typically changed at a slower rate.
Definition: info.hpp:312
bool has() const
True if (and only if) the field has a value.
Definition: info.cpp:54
A message field for an angle measurement which does not lose precision at very high angles.
Definition: info.hpp:119
#define HEBI_DISABLE_COPY(Class)
Definition: util.hpp:16
Actuator-specific settings, such as controller gains.
Definition: info.hpp:315
const FloatField & effortLimitMin() const
The firmware safety limit for the minimum allowed effort.
Definition: info.hpp:356
bool has() const
True if (and only if) the field has a value.
Definition: info.cpp:44
const LedField & led() const
The module's LED.
Definition: info.hpp:507
const FloatField & springConstant() const
The spring constant of the module.
Definition: info.hpp:350
T get() const
If the field has a value, returns that value; otherwise, returns a default.
Definition: info.hpp:267
const FloatField & effortLimitMax() const
The firmware safety limit for the maximum allowed effort.
Definition: info.hpp:358
const EnumField< ControlStrategy > & controlStrategy() const
How the position, velocity, and effort PID loops are connected in order to control motor PWM.
Definition: info.hpp:364
PositionLimitStrategy
Definition: info.hpp:71
A message field representable by a bool value.
Definition: info.hpp:165
Definition: arm.cpp:5
const HighResAngleField & positionLimitMax() const
The firmware safety limit for the maximum allowed position.
Definition: info.hpp:362
Actuator-specific information.
Definition: info.hpp:452
const EnumField< CalibrationState > & calibrationState() const
The calibration state of the module.
Definition: info.hpp:464
const Actuator & actuator() const
Actuator-specific settings, such as controller gains.
Definition: info.hpp:428
const InfoGains & effortGains() const
Controller gains for the effort PID loop.
Definition: info.hpp:345
Info objects have various fields representing the module state; which fields are populated depends on...
Definition: info.hpp:33
const StringField & serial() const
Gets the serial number for this module (e.g., X5-0001).
Definition: info.hpp:505
MstopStrategy
Definition: info.hpp:62
CalibrationState
Definition: info.hpp:51
#define HEBI_DISABLE_COPY_MOVE(Class)
Definition: util.hpp:6
const Imu & imu() const
IMU-specific settings.
Definition: info.hpp:430
const InfoGains & positionGains() const
Controller gains for the position PID loop.
Definition: info.hpp:341
const Actuator & actuator() const
Actuator-specific information.
Definition: info.hpp:500
A two-state message field (either set/true or cleared/false).
Definition: info.hpp:214
const BoolField & accelIncludesGravity() const
Whether to include acceleration due to gravity in acceleration feedback.
Definition: info.hpp:405
A message field for interfacing with an LED.
Definition: info.hpp:280
const FloatField & velocityLimitMin() const
The firmware safety limit for the minimum allowed velocity.
Definition: info.hpp:352
const InfoGains & velocityGains() const
Controller gains for the velocity PID loop.
Definition: info.hpp:343
Triggering the M-Stop results in the control strategy being set to 'off'. Remains 'off' until changed...
const Settings & settings() const
Module settings that are typically changed at a slower rate.
Definition: info.hpp:498
A direct PWM value (-1 to 1) can be sent to the motor (subject to onboard safety limiting).
HebiStatusCode enumGetter(const RefT &ref, MetadataT &metadata, int field, int32_t *value)
Definition: message_helpers.cpp:298
The effort (e.g., spring nonlinearity) has not been calibrated.
The motor is not given power (equivalent to a 0 PWM value)
The current has not been calibrated.
Info & operator=(Info &&other)=delete
ControlStrategy
Definition: info.hpp:35
Info(Info &&other)
Move constructor (necessary for containment in STL template classes)
Definition: info.cpp:93
double get() const
If the field has a value, returns that value as a double; otherwise, returns a default.
Definition: info.cpp:26
A message field representable by a std::string.
Definition: info.hpp:183
bool has() const
True if (and only if) the field has a value.
Definition: info.cpp:9
const StringField & family() const
Gets the family for this module.
Definition: info.hpp:437
Color getColor() const
Returns the led color.
Definition: info.cpp:82
Exceeding the position limit results in the control strategy being set to 'off'. Remains 'off' until ...
float get() const
If the field has a value, returns that value; otherwise, returns a default.
Definition: info.cpp:11
const FloatField & velocityLimitMax() const
The firmware safety limit for the maximum allowed velocity.
Definition: info.hpp:354
const StringField & name() const
Gets the name for this module.
Definition: info.hpp:435
The module has been calibrated; this is the normal state.
bool hasColor() const
Returns true if the LED color is set, and false otherwise.
Definition: info.cpp:78
Triggering the M-Stop has no effect.
const EnumField< PositionLimitStrategy > & minPositionLimitStrategy() const
The position limit strategy (at the minimum position) for the actuator.
Definition: info.hpp:368
bool get() const
If the field has a value, returns that value; otherwise, returns false.
Definition: info.cpp:46
const EnumField< PositionLimitStrategy > & maxPositionLimitStrategy() const
The position limit strategy (at the maximum position) for the actuator.
Definition: info.hpp:370
Exceeding the position limit has no effect.
A message field representable by an enum of a given type.
Definition: info.hpp:243
Structure to describe an RGB color.
Definition: color.hpp:8
IMU-specific settings.
Definition: info.hpp:392
Exceeding the position limit results in the actuator holding the position. Needs to be manually set t...
Exceeding the position limit results in a virtual spring that pushes the actuator back to within the ...
bool has() const
True if (and only if) the field has a value.
Definition: info.cpp:22
const EnumField< MstopStrategy > & mstopStrategy() const
The motion stop strategy for the actuator.
Definition: info.hpp:366
bool has() const
Returns true if the flag is set, false if it is cleared.
Definition: info.cpp:74
Triggering the M-Stop results in the motor holding the motor position. Operations resume to normal on...
A message field representable by a single-precision floating point value.
Definition: info.hpp:84
The factory zero position has not been set.
bool has() const
True if (and only if) the field has a value.
Definition: info.hpp:262