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 IoBank final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    IoBank(HebiInfoPtr internal, HebiInfoRef& internal_ref, HebiInfoIoPinBank bank);
#endif // DOXYGEN_OMIT_INTERNAL
    bool hasLabel(size_t pinNumber) const;
    std::string getLabel(size_t pinNumber) const;

    HEBI_DISABLE_COPY_MOVE(IoBank)
  private:
    HebiInfoPtr internal_;
    HebiInfoRef& internal_ref_;
    HebiInfoIoPinBank const bank_;
  };
  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_;
  };

  class Io final {
  public:
#ifndef DOXYGEN_OMIT_INTERNAL
    Io(HebiInfoPtr internal, HebiInfoRef& internal_ref)
      : a_(internal, internal_ref, HebiInfoIoBankA),
        b_(internal, internal_ref, HebiInfoIoBankB),
        c_(internal, internal_ref, HebiInfoIoBankC),
        d_(internal, internal_ref, HebiInfoIoBankD),
        e_(internal, internal_ref, HebiInfoIoBankE),
        f_(internal, internal_ref, HebiInfoIoBankF) {}
#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 ----------------

    IoBank& a() { return a_; }
    const IoBank& a() const { return a_; }
    IoBank& b() { return b_; }
    const IoBank& b() const { return b_; }
    IoBank& c() { return c_; }
    const IoBank& c() const { return c_; }
    IoBank& d() { return d_; }
    const IoBank& d() const { return d_; }
    IoBank& e() { return e_; }
    const IoBank& e() const { return e_; }
    IoBank& f() { return f_; }
    const IoBank& f() const { return f_; }

    HEBI_DISABLE_COPY_MOVE(Io)
  private:
    IoBank a_;
    IoBank b_;
    IoBank c_;
    IoBank d_;
    IoBank e_;
    IoBank f_;
  };

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

  Io& io() { return io_; }
  const Io& io() const { return io_; }
  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:
  Io io_;
  Settings settings_;
  Actuator actuator_;

  StringField serial_;
  LedField led_;
};

} // namespace hebi