info.hpp

Go to the documentation of this file.

#pragma once
 
#include "hebi.h"
 
#include <string>
 
#include "color.hpp"
#include "gains.hpp"
#include "message_helpers.hpp"
#include "util.hpp"
 
namespace hebi {
 
class Info final {
public:
  enum class ControlStrategy {
    Off,
    DirectPWM,
    Strategy2,
    Strategy3,
    Strategy4,
  };
 
  enum class CalibrationState {
    Normal,
    UncalibratedCurrent,
    UncalibratedPosition,
    UncalibratedEffort,
  };
 
  enum class MstopStrategy {
    Disabled,
    MotorOff,
    HoldPosition,
  };
 
  enum class PositionLimitStrategy {
    HoldPosition,
    DampedSpring,
    MotorOff,
    Disabled,
  };
 
protected:
  class FloatField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    FloatField(const HebiInfoRef& internal, HebiInfoFloatField field);
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return has(); }
    bool has() const;
    float get() const;
 
    HEBI_DISABLE_COPY_MOVE(FloatField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoFloatField const field_;
  };
 
  class HighResAngleField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    HighResAngleField(const HebiInfoRef& internal, HebiInfoHighResAngleField field);
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return has(); }
    bool has() const;
    double get() const;
    void get(int64_t* revolutions, float* radian_offset) const;
 
    HEBI_DISABLE_COPY_MOVE(HighResAngleField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoHighResAngleField const field_;
  };
 
  class BoolField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    BoolField(const HebiInfoRef& internal, HebiInfoBoolField field);
#endif // DOXYGEN_OMIT_INTERNAL
    bool has() const;
    bool get() const;
 
    HEBI_DISABLE_COPY_MOVE(BoolField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoBoolField const field_;
  };
 
  class StringField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    StringField(HebiInfoPtr internal, HebiInfoStringField field);
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return has(); }
    bool has() const;
    std::string get() const;
 
    HEBI_DISABLE_COPY_MOVE(StringField)
  private:
    HebiInfoPtr const internal_;
    HebiInfoStringField const field_;
  };
 
  class FlagField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    FlagField(const HebiInfoRef& internal, HebiInfoFlagField field);
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return has(); }
    bool has() const;
 
    HEBI_DISABLE_COPY_MOVE(FlagField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoFlagField const field_;
  };
 
  template<typename T>
  class EnumField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    EnumField(const HebiInfoRef& internal, HebiInfoEnumField field) : internal_(internal), field_(field) {}
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return has(); }
    bool has() const {
      return (enumGetter(internal_, field_, nullptr) == HebiStatusSuccess);
    }
    T get() const {
      int32_t ret{};
      enumGetter(internal_, field_, &ret);
      return static_cast<T>(ret);
    }
 
    HEBI_DISABLE_COPY_MOVE(EnumField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoEnumField const field_;
  };
 
  class LedField final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    LedField(const HebiInfoRef& internal, HebiInfoLedField field);
#endif // DOXYGEN_OMIT_INTERNAL
    explicit operator bool() const { return hasColor(); }
    bool hasColor() const;
    Color getColor() const;
 
    HEBI_DISABLE_COPY_MOVE(LedField)
  private:
    const HebiInfoRef& internal_;
    HebiInfoLedField const field_;
  };
 
  using InfoGains = Gains<HebiInfoRef, FloatField, BoolField, HebiInfoFloatField, HebiInfoBoolField>;
 
  class Settings final {
  protected:
    class Actuator final {
    public:
#ifndef DOXYGEN_OMIT_INTERNAL
      Actuator(const HebiInfoRef& internal)
        : position_gains_(internal, HebiInfoFloatPositionKp, HebiInfoBoolPositionDOnError),
          velocity_gains_(internal, HebiInfoFloatVelocityKp, HebiInfoBoolVelocityDOnError),
          effort_gains_(internal, HebiInfoFloatEffortKp, HebiInfoBoolEffortDOnError),
          spring_constant_(internal, HebiInfoFloatSpringConstant),
          velocity_limit_min_(internal, HebiInfoFloatVelocityLimitMin),
          velocity_limit_max_(internal, HebiInfoFloatVelocityLimitMax),
          effort_limit_min_(internal, HebiInfoFloatEffortLimitMin),
          effort_limit_max_(internal, HebiInfoFloatEffortLimitMax),
          position_limit_min_(internal, HebiInfoHighResAnglePositionLimitMin),
          position_limit_max_(internal, HebiInfoHighResAnglePositionLimitMax),
          control_strategy_(internal, HebiInfoEnumControlStrategy),
          mstop_strategy_(internal, HebiInfoEnumMstopStrategy),
          min_position_limit_strategy_(internal, HebiInfoEnumMinPositionLimitStrategy),
          max_position_limit_strategy_(internal, HebiInfoEnumMaxPositionLimitStrategy) {}
#endif // DOXYGEN_OMIT_INTERNAL
 
      // With all submessage and field getters: Note that the returned reference
      // should not be used after the lifetime of this parent.
 
      // Submessages ----------------
 
      const InfoGains& positionGains() const { return position_gains_; }
      const InfoGains& velocityGains() const { return velocity_gains_; }
      const InfoGains& effortGains() const { return effort_gains_; }
 
      // Subfields ----------------
 
      const FloatField& springConstant() const { return spring_constant_; }
      const FloatField& velocityLimitMin() const { return velocity_limit_min_; }
      const FloatField& velocityLimitMax() const { return velocity_limit_max_; }
      const FloatField& effortLimitMin() const { return effort_limit_min_; }
      const FloatField& effortLimitMax() const { return effort_limit_max_; }
      const HighResAngleField& positionLimitMin() const { return position_limit_min_; }
      const HighResAngleField& positionLimitMax() const { return position_limit_max_; }
      const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
      const EnumField<MstopStrategy>& mstopStrategy() const { return mstop_strategy_; }
      const EnumField<PositionLimitStrategy>& minPositionLimitStrategy() const { return min_position_limit_strategy_; }
      const EnumField<PositionLimitStrategy>& maxPositionLimitStrategy() const { return max_position_limit_strategy_; }
 
      HEBI_DISABLE_COPY_MOVE(Actuator)
    private:
      InfoGains position_gains_;
      InfoGains velocity_gains_;
      InfoGains effort_gains_;
 
      FloatField spring_constant_;
      FloatField velocity_limit_min_;
      FloatField velocity_limit_max_;
      FloatField effort_limit_min_;
      FloatField effort_limit_max_;
      HighResAngleField position_limit_min_;
      HighResAngleField position_limit_max_;
      EnumField<ControlStrategy> control_strategy_;
      EnumField<MstopStrategy> mstop_strategy_;
      EnumField<PositionLimitStrategy> min_position_limit_strategy_;
      EnumField<PositionLimitStrategy> max_position_limit_strategy_;
    };
 
    class Imu final {
    public:
#ifndef DOXYGEN_OMIT_INTERNAL
      Imu(const HebiInfoRef& internal)
        : accel_includes_gravity_(internal, HebiInfoBoolAccelIncludesGravity) {}
#endif // DOXYGEN_OMIT_INTERNAL
 
      // With all submessage and field getters: Note that the returned reference
      // should not be used after the lifetime of this parent.
 
      // Subfields ----------------
 
      const BoolField& accelIncludesGravity() const { return accel_includes_gravity_; }
 
      HEBI_DISABLE_COPY_MOVE(Imu)
    private:
      BoolField accel_includes_gravity_;
    };
 
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    Settings(HebiInfoPtr internal_ptr, const HebiInfoRef& internal)
      : actuator_(internal),
        imu_(internal),
        name_(internal_ptr, HebiInfoStringName),
        family_(internal_ptr, HebiInfoStringFamily),
        save_current_settings_(internal, HebiInfoFlagSaveCurrentSettings) {}
#endif // DOXYGEN_OMIT_INTERNAL
 
    // With all submessage and field getters: Note that the returned reference
    // should not be used after the lifetime of this parent.
 
    // Submessages ----------------
 
    const Actuator& actuator() const { return actuator_; }
    const Imu& imu() const { return imu_; }
 
    // Subfields ----------------
 
    const StringField& name() const { return name_; }
    const StringField& family() const { return family_; }
    const FlagField& saveCurrentSettings() const { return save_current_settings_; }
 
    HEBI_DISABLE_COPY_MOVE(Settings)
  private:
    Actuator actuator_;
    Imu imu_;
 
    StringField name_;
    StringField family_;
    FlagField save_current_settings_;
  };
 
  class Actuator final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    Actuator(const HebiInfoRef& internal) : calibration_state_(internal, HebiInfoEnumCalibrationState) {}
#endif // DOXYGEN_OMIT_INTERNAL
 
    // With all submessage and field getters: Note that the returned reference
    // should not be used after the lifetime of this parent.
 
    // Subfields ----------------
 
    const EnumField<CalibrationState>& calibrationState() const { return calibration_state_; }
 
    HEBI_DISABLE_COPY_MOVE(Actuator)
  private:
    EnumField<CalibrationState> calibration_state_;
  };
 
private:
  HebiInfoPtr internal_;
  HebiInfoRef internal_ref_;
 
public:
#ifndef DOXYGEN_OMIT_INTERNAL
 
  Info(HebiInfoPtr);
#endif // DOXYGEN_OMIT_INTERNAL
 
  Info(Info&& other);
 
  // With all submessage and field getters: Note that the returned reference
  // should not be used after the lifetime of this parent.
 
  // Submessages -------------------------------------------------------------
 
  const Settings& settings() const { return settings_; }
  const Actuator& actuator() const { return actuator_; }
 
  // Subfields -------------------------------------------------------------
 
  const StringField& serial() const { return serial_; }
  const LedField& led() const { return led_; }
 
  HEBI_DISABLE_COPY(Info)
 
  /* Disable move assigment operator. */
  Info& operator=(Info&& other) = delete;
 
private:
  Settings settings_;
  Actuator actuator_;
 
  StringField serial_;
  LedField led_;
};
 
} // namespace hebi