info.hpp

Go to the documentation of this file.

#pragma once

#include "hebi.h"
#include "color.hpp"
#include <string>
#include "util.hpp"
#include "gains.hpp"

namespace hebi {

class Info final
{
  public:
    enum class ControlStrategy {
      Off,
      DirectPWM,
      Strategy2,
      Strategy3,
      Strategy4,
    };

    enum class CalibrationState {
      Normal,
      UncalibratedCurrent,
      UncalibratedPosition,
      UncalibratedEffort,
    };

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

      private:
        HebiInfoPtr const internal_;
        HebiInfoFloatField const field_;

        HEBI_DISABLE_COPY_MOVE(FloatField)
    };
    class HighResAngleField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        HighResAngleField(HebiInfoPtr internal, HebiInfoHighResAngleField 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:
        HebiInfoPtr const internal_;
        HebiInfoHighResAngleField const field_;

        HEBI_DISABLE_COPY_MOVE(HighResAngleField)
    };

    class BoolField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        BoolField(HebiInfoPtr internal, HebiInfoBoolField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool has() const;
        bool get() const;

      private:
        HebiInfoPtr const internal_;
        HebiInfoBoolField const field_;

        HEBI_DISABLE_COPY_MOVE(BoolField)
    };

    class StringField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        StringField(HebiInfoPtr internal, HebiInfoStringField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        std::string get() const;

      private:
        HebiInfoPtr const internal_;
        HebiInfoStringField const field_;

        HEBI_DISABLE_COPY_MOVE(StringField)
    };

    class FlagField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        FlagField(HebiInfoPtr internal, HebiInfoFlagField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;

      private:
        HebiInfoPtr const internal_;
        HebiInfoFlagField const field_;

        HEBI_DISABLE_COPY_MOVE(FlagField)
    };

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

      private:
        HebiInfoPtr const internal_;
        HebiInfoEnumField const field_;

        HEBI_DISABLE_COPY_MOVE(EnumField)
    };

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

      private:
        HebiInfoPtr const internal_;
        HebiInfoLedField const field_;

        HEBI_DISABLE_COPY_MOVE(LedField)
    };

    using InfoGains = Gains<HebiInfoPtr, FloatField, BoolField, HebiInfoFloatField, HebiInfoBoolField>;

    class Settings final
    {
      // Note: this is 'protected' instead of 'private' for easier use with Doxygen
      protected:
        class Actuator final
        {
          public:
            #ifndef DOXYGEN_OMIT_INTERNAL
            Actuator(HebiInfoPtr internal)
              : internal_(internal),
                position_gains_(internal, HebiInfoFloatPositionKp, HebiInfoBoolPositionDOnError),
                velocity_gains_(internal, HebiInfoFloatVelocityKp, HebiInfoBoolVelocityDOnError),
                effort_gains_(internal, HebiInfoFloatEffortKp, HebiInfoBoolEffortDOnError),
                spring_constant_(internal, HebiInfoFloatSpringConstant),
                position_limit_min_(internal, HebiInfoHighResAnglePositionLimitMin),
                position_limit_max_(internal, HebiInfoHighResAnglePositionLimitMax),
                control_strategy_(internal, HebiInfoEnumControlStrategy)
            {
            }
            #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 HighResAngleField& positionLimitMin() const { return position_limit_min_; }
            const HighResAngleField& positionLimitMax() const { return position_limit_max_; }
            const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
        
          private:
            HebiInfoPtr const internal_;
        
            InfoGains position_gains_;
            InfoGains velocity_gains_;
            InfoGains effort_gains_;
        
            FloatField spring_constant_;
            HighResAngleField position_limit_min_;
            HighResAngleField position_limit_max_;
            EnumField<ControlStrategy> control_strategy_;
        
            HEBI_DISABLE_COPY_MOVE(Actuator)
        };
    
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Settings(HebiInfoPtr internal)
          : internal_(internal),
            actuator_(internal),
            name_(internal, HebiInfoStringName),
            family_(internal, 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_; }
    
        // Subfields ----------------
    
        const StringField& name() const { return name_; }
        const StringField& family() const { return family_; }
        const FlagField& saveCurrentSettings() const { return save_current_settings_; }
    
      private:
        HebiInfoPtr const internal_;
    
        Actuator actuator_;
    
        StringField name_;
        StringField family_;
        FlagField save_current_settings_;
    
        HEBI_DISABLE_COPY_MOVE(Settings)
    };

    class Actuator final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Actuator(HebiInfoPtr internal)
          : internal_(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_; }
    
      private:
        HebiInfoPtr const internal_;
    
        EnumField<CalibrationState> calibration_state_;
    
        HEBI_DISABLE_COPY_MOVE(Actuator)
    };

  private:
    HebiInfoPtr internal_;

  public:
    #ifndef DOXYGEN_OMIT_INTERNAL

    Info(HebiInfoPtr );
    #endif // DOXYGEN_OMIT_INTERNAL

    Info(Info&& other);
    ~Info() 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 Settings& settings() const { return settings_; }
    const Actuator& actuator() const { return actuator_; }

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

    const LedField& led() const;

    const StringField& serial() const { return serial_; }
    
  private:
    Settings settings_;
    Actuator actuator_;

    LedField led_;
  
    StringField serial_;

    HEBI_DISABLE_COPY(Info)

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

} // namespace hebi