feedback.hpp

Go to the documentation of this file.

#pragma once

#include "hebi.h"
#include "color.hpp"
#include "vector_3_f.hpp"
#include "quaternion_f.hpp"
#include "util.hpp"

namespace hebi {

class Feedback final
  {
  public:
    enum class TemperatureState
    {
      Normal,
      Critical,
      ExceedMaxMotor,
      ExceedMaxBoard,
    };

    enum class MstopState
    {
      Triggered,
      NotTriggered,
    };

    enum class PositionLimitState
    {
      Below,
      AtLower,
      Inside,
      AtUpper,
      Above,
      Uninitialized,
    };

    enum class VelocityLimitState
    {
      Below,
      AtLower,
      Inside,
      AtUpper,
      Above,
      Uninitialized,
    };

    enum class EffortLimitState
    {
      Below,
      AtLower,
      Inside,
      AtUpper,
      Above,
      Uninitialized,
    };

    enum class CommandLifetimeState
    {
      Unlocked,
      LockedByOther,
      LockedBySender,
    };

  // Note: this is 'protected' instead of 'private' for easier use with Doxygen
  protected:
    class FloatField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        FloatField(HebiFeedbackPtr internal, HebiFeedbackFloatField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        float get() const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackFloatField const field_;

        HEBI_DISABLE_COPY_MOVE(FloatField)
    };
    class HighResAngleField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        HighResAngleField(HebiFeedbackPtr internal, HebiFeedbackHighResAngleField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        double get() const;
        void get(int64_t* revolutions, float* radian_offset) const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackHighResAngleField const field_;

        HEBI_DISABLE_COPY_MOVE(HighResAngleField)
    };

    class NumberedFloatField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        NumberedFloatField(HebiFeedbackPtr internal, HebiFeedbackNumberedFloatField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool has(size_t fieldNumber) const;
        float get(size_t fieldNumber) const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackNumberedFloatField const field_;

        HEBI_DISABLE_COPY_MOVE(NumberedFloatField)
    };

    class UInt64Field final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        UInt64Field(HebiFeedbackPtr internal, HebiFeedbackUInt64Field field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        uint64_t get() const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackUInt64Field const field_;

        HEBI_DISABLE_COPY_MOVE(UInt64Field)
    };
    class Vector3fField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Vector3fField(HebiFeedbackPtr internal, HebiFeedbackVector3fField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        Vector3f get() const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackVector3fField const field_;

        HEBI_DISABLE_COPY_MOVE(Vector3fField)
    };

    class QuaternionfField final {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        QuaternionfField(HebiFeedbackPtr internal, HebiFeedbackQuaternionfField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        Quaternionf get() const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackQuaternionfField const field_;

        HEBI_DISABLE_COPY_MOVE(QuaternionfField)
    };

    template <typename T>
    class EnumField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        EnumField(HebiFeedbackPtr internal, HebiFeedbackEnumField field)
          : internal_(internal), field_(field) {}
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const { return has(); }
        bool has() const { return (hebiFeedbackGetEnum(internal_, field_, nullptr) == HebiStatusSuccess); }
        T get() const { int32_t ret; hebiFeedbackGetEnum(internal_, field_, &ret); return static_cast<T>(ret); }

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackEnumField const field_;

        HEBI_DISABLE_COPY_MOVE(EnumField)
    };

    class IoBank final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        IoBank(HebiFeedbackPtr internal, HebiFeedbackIoPinBank bank);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool hasInt(size_t pinNumber) const;
        bool hasFloat(size_t pinNumber) const;
        int64_t getInt(size_t pinNumber) const;
        float getFloat(size_t pinNumber) const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackIoPinBank const bank_;

        HEBI_DISABLE_COPY_MOVE(IoBank);
    };
    class LedField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        LedField(HebiFeedbackPtr internal, HebiFeedbackLedField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const { return hasColor(); }
        bool hasColor() const;
        Color getColor() const;

      private:
        HebiFeedbackPtr const internal_;
        HebiFeedbackLedField const field_;

        HEBI_DISABLE_COPY_MOVE(LedField)
    };

    class Io final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Io(HebiFeedbackPtr internal)
          : internal_(internal),
            a_(internal, HebiFeedbackIoBankA),
            b_(internal, HebiFeedbackIoBankB),
            c_(internal, HebiFeedbackIoBankC),
            d_(internal, HebiFeedbackIoBankD),
            e_(internal, HebiFeedbackIoBankE),
            f_(internal, HebiFeedbackIoBankF)
        {
        }
        #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 IoBank& a() const { return a_; }
        const IoBank& b() const { return b_; }
        const IoBank& c() const { return c_; }
        const IoBank& d() const { return d_; }
        const IoBank& e() const { return e_; }
        const IoBank& f() const { return f_; }
    
      private:
        HebiFeedbackPtr const internal_;
    
        IoBank a_;
        IoBank b_;
        IoBank c_;
        IoBank d_;
        IoBank e_;
        IoBank f_;
    
        HEBI_DISABLE_COPY_MOVE(Io)
    };

    class Actuator final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Actuator(HebiFeedbackPtr internal)
          : internal_(internal),
            velocity_(internal, HebiFeedbackFloatVelocity),
            effort_(internal, HebiFeedbackFloatEffort),
            velocity_command_(internal, HebiFeedbackFloatVelocityCommand),
            effort_command_(internal, HebiFeedbackFloatEffortCommand),
            deflection_(internal, HebiFeedbackFloatDeflection),
            deflection_velocity_(internal, HebiFeedbackFloatDeflectionVelocity),
            motor_velocity_(internal, HebiFeedbackFloatMotorVelocity),
            motor_current_(internal, HebiFeedbackFloatMotorCurrent),
            motor_sensor_temperature_(internal, HebiFeedbackFloatMotorSensorTemperature),
            motor_winding_current_(internal, HebiFeedbackFloatMotorWindingCurrent),
            motor_winding_temperature_(internal, HebiFeedbackFloatMotorWindingTemperature),
            motor_housing_temperature_(internal, HebiFeedbackFloatMotorHousingTemperature),
            position_(internal, HebiFeedbackHighResAnglePosition),
            position_command_(internal, HebiFeedbackHighResAnglePositionCommand),
            sequence_number_(internal, HebiFeedbackUInt64SequenceNumber),
            receive_time_(internal, HebiFeedbackUInt64ReceiveTime),
            transmit_time_(internal, HebiFeedbackUInt64TransmitTime),
            hardware_receive_time_(internal, HebiFeedbackUInt64HardwareReceiveTime),
            hardware_transmit_time_(internal, HebiFeedbackUInt64HardwareTransmitTime),
            sender_id_(internal, HebiFeedbackUInt64SenderId),
            temperature_state_(internal, HebiFeedbackEnumTemperatureState),
            mstop_state_(internal, HebiFeedbackEnumMstopState),
            position_limit_state_(internal, HebiFeedbackEnumPositionLimitState),
            velocity_limit_state_(internal, HebiFeedbackEnumVelocityLimitState),
            effort_limit_state_(internal, HebiFeedbackEnumEffortLimitState),
            command_lifetime_state_(internal, HebiFeedbackEnumCommandLifetimeState)
        {
        }
        #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 FloatField& velocity() const { return velocity_; }
        const FloatField& effort() const { return effort_; }
        const FloatField& velocityCommand() const { return velocity_command_; }
        const FloatField& effortCommand() const { return effort_command_; }
        const FloatField& deflection() const { return deflection_; }
        const FloatField& deflectionVelocity() const { return deflection_velocity_; }
        const FloatField& motorVelocity() const { return motor_velocity_; }
        const FloatField& motorCurrent() const { return motor_current_; }
        const FloatField& motorSensorTemperature() const { return motor_sensor_temperature_; }
        const FloatField& motorWindingCurrent() const { return motor_winding_current_; }
        const FloatField& motorWindingTemperature() const { return motor_winding_temperature_; }
        const FloatField& motorHousingTemperature() const { return motor_housing_temperature_; }
        const HighResAngleField& position() const { return position_; }
        const HighResAngleField& positionCommand() const { return position_command_; }
        const UInt64Field& sequenceNumber() const { return sequence_number_; }
        const UInt64Field& receiveTime() const { return receive_time_; }
        const UInt64Field& transmitTime() const { return transmit_time_; }
        const UInt64Field& hardwareReceiveTime() const { return hardware_receive_time_; }
        const UInt64Field& hardwareTransmitTime() const { return hardware_transmit_time_; }
        const UInt64Field& senderId() const { return sender_id_; }
        const EnumField<TemperatureState>& temperatureState() const { return temperature_state_; }
        const EnumField<MstopState>& mstopState() const { return mstop_state_; }
        const EnumField<PositionLimitState>& positionLimitState() const { return position_limit_state_; }
        const EnumField<VelocityLimitState>& velocityLimitState() const { return velocity_limit_state_; }
        const EnumField<EffortLimitState>& effortLimitState() const { return effort_limit_state_; }
        const EnumField<CommandLifetimeState>& commandLifetimeState() const { return command_lifetime_state_; }
    
      private:
        HebiFeedbackPtr const internal_;
    
        FloatField velocity_;
        FloatField effort_;
        FloatField velocity_command_;
        FloatField effort_command_;
        FloatField deflection_;
        FloatField deflection_velocity_;
        FloatField motor_velocity_;
        FloatField motor_current_;
        FloatField motor_sensor_temperature_;
        FloatField motor_winding_current_;
        FloatField motor_winding_temperature_;
        FloatField motor_housing_temperature_;
        HighResAngleField position_;
        HighResAngleField position_command_;
        UInt64Field sequence_number_;
        UInt64Field receive_time_;
        UInt64Field transmit_time_;
        UInt64Field hardware_receive_time_;
        UInt64Field hardware_transmit_time_;
        UInt64Field sender_id_;
        EnumField<TemperatureState> temperature_state_;
        EnumField<MstopState> mstop_state_;
        EnumField<PositionLimitState> position_limit_state_;
        EnumField<VelocityLimitState> velocity_limit_state_;
        EnumField<EffortLimitState> effort_limit_state_;
        EnumField<CommandLifetimeState> command_lifetime_state_;
    
        HEBI_DISABLE_COPY_MOVE(Actuator)
    };

    class Imu final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Imu(HebiFeedbackPtr internal)
          : internal_(internal),
            accelerometer_(internal, HebiFeedbackVector3fAccelerometer),
            gyro_(internal, HebiFeedbackVector3fGyro),
            orientation_(internal, HebiFeedbackQuaternionfOrientation)
        {
        }
        #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 Vector3fField& accelerometer() const { return accelerometer_; }
        const Vector3fField& gyro() const { return gyro_; }
        const QuaternionfField& orientation() const { return orientation_; }
    
      private:
        HebiFeedbackPtr const internal_;
    
        Vector3fField accelerometer_;
        Vector3fField gyro_;
        QuaternionfField orientation_;
    
        HEBI_DISABLE_COPY_MOVE(Imu)
    };

  private:
    HebiFeedbackPtr internal_;

  public:
    #ifndef DOXYGEN_OMIT_INTERNAL

    Feedback(HebiFeedbackPtr );
    #endif // DOXYGEN_OMIT_INTERNAL

    Feedback(Feedback&& other);
    ~Feedback() noexcept; /* annotating specified destructor as noexcept is best-practice */

    // With all submessage and field getters: Note that the returned reference
    // should not be used after the lifetime of this parent.

    // Submessages -------------------------------------------------------------

    const Io& io() const { return io_; }
    const Actuator& actuator() const { return actuator_; }
    const Imu& imu() const { return imu_; }

    // Subfields -------------------------------------------------------------

    const FloatField& boardTemperature() const;
    const FloatField& processorTemperature() const;
    const FloatField& voltage() const;
    #ifndef DOXYGEN_OMIT_INTERNAL
    const NumberedFloatField& debug() const;
    #endif // DOXYGEN_OMIT_INTERNAL
    const LedField& led() const;

  private:
    Io io_;
    Actuator actuator_;
    Imu imu_;

    FloatField board_temperature_;
    FloatField processor_temperature_;
    FloatField voltage_;
    NumberedFloatField debug_;
    LedField led_;

    HEBI_DISABLE_COPY(Feedback)

    /* Disable move assigment operator. */
    Feedback& operator= (const Feedback&& other) = delete;
};

} // namespace hebi