info.hpp

Go to the documentation of this file.

#pragma once

#include "hebi_info.h"
#include "color.hpp"
#include <string>
#include "util.hpp"

namespace hebi {

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

  // 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 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 <class 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 { T ret; hebiInfoGetEnum(internal_, field_, reinterpret_cast<int*>(&ret)); return 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)
    };

    class Settings final
    {
      // Note: this is 'protected' instead of 'private' for easier use with Doxygen
      protected:
        class Actuator final
        {
          // Note: this is 'protected' instead of 'private' for easier use with Doxygen
          protected:
            class PositionGains final
            {
              public:
                #ifndef DOXYGEN_OMIT_INTERNAL
                PositionGains(HebiInfoPtr internal)
                  : internal_(internal),
                    position_kp_(internal, HebiInfoFloatPositionKp),
                    position_ki_(internal, HebiInfoFloatPositionKi),
                    position_kd_(internal, HebiInfoFloatPositionKd),
                    position_feed_forward_(internal, HebiInfoFloatPositionFeedForward),
                    position_dead_zone_(internal, HebiInfoFloatPositionDeadZone),
                    position_i_clamp_(internal, HebiInfoFloatPositionIClamp),
                    position_punch_(internal, HebiInfoFloatPositionPunch),
                    position_min_target_(internal, HebiInfoFloatPositionMinTarget),
                    position_max_target_(internal, HebiInfoFloatPositionMaxTarget),
                    position_target_lowpass_(internal, HebiInfoFloatPositionTargetLowpass),
                    position_min_output_(internal, HebiInfoFloatPositionMinOutput),
                    position_max_output_(internal, HebiInfoFloatPositionMaxOutput),
                    position_output_lowpass_(internal, HebiInfoFloatPositionOutputLowpass),
                    position_d_on_error_(internal, HebiInfoBoolPositionDOnError)
                {
                }
                #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& positionKp() const { return position_kp_; }
                const FloatField& positionKi() const { return position_ki_; }
                const FloatField& positionKd() const { return position_kd_; }
                const FloatField& positionFeedForward() const { return position_feed_forward_; }
                const FloatField& positionDeadZone() const { return position_dead_zone_; }
                const FloatField& positionIClamp() const { return position_i_clamp_; }
                const FloatField& positionPunch() const { return position_punch_; }
                const FloatField& positionMinTarget() const { return position_min_target_; }
                const FloatField& positionMaxTarget() const { return position_max_target_; }
                const FloatField& positionTargetLowpass() const { return position_target_lowpass_; }
                const FloatField& positionMinOutput() const { return position_min_output_; }
                const FloatField& positionMaxOutput() const { return position_max_output_; }
                const FloatField& positionOutputLowpass() const { return position_output_lowpass_; }
                const BoolField& positionDOnError() const { return position_d_on_error_; }
            
              private:
                HebiInfoPtr const internal_;
            
                FloatField position_kp_;
                FloatField position_ki_;
                FloatField position_kd_;
                FloatField position_feed_forward_;
                FloatField position_dead_zone_;
                FloatField position_i_clamp_;
                FloatField position_punch_;
                FloatField position_min_target_;
                FloatField position_max_target_;
                FloatField position_target_lowpass_;
                FloatField position_min_output_;
                FloatField position_max_output_;
                FloatField position_output_lowpass_;
                BoolField position_d_on_error_;
            
                HEBI_DISABLE_COPY_MOVE(PositionGains)
            };
        
            class VelocityGains final
            {
              public:
                #ifndef DOXYGEN_OMIT_INTERNAL
                VelocityGains(HebiInfoPtr internal)
                  : internal_(internal),
                    velocity_kp_(internal, HebiInfoFloatVelocityKp),
                    velocity_ki_(internal, HebiInfoFloatVelocityKi),
                    velocity_kd_(internal, HebiInfoFloatVelocityKd),
                    velocity_feed_forward_(internal, HebiInfoFloatVelocityFeedForward),
                    velocity_dead_zone_(internal, HebiInfoFloatVelocityDeadZone),
                    velocity_i_clamp_(internal, HebiInfoFloatVelocityIClamp),
                    velocity_punch_(internal, HebiInfoFloatVelocityPunch),
                    velocity_min_target_(internal, HebiInfoFloatVelocityMinTarget),
                    velocity_max_target_(internal, HebiInfoFloatVelocityMaxTarget),
                    velocity_target_lowpass_(internal, HebiInfoFloatVelocityTargetLowpass),
                    velocity_min_output_(internal, HebiInfoFloatVelocityMinOutput),
                    velocity_max_output_(internal, HebiInfoFloatVelocityMaxOutput),
                    velocity_output_lowpass_(internal, HebiInfoFloatVelocityOutputLowpass),
                    velocity_d_on_error_(internal, HebiInfoBoolVelocityDOnError)
                {
                }
                #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& velocityKp() const { return velocity_kp_; }
                const FloatField& velocityKi() const { return velocity_ki_; }
                const FloatField& velocityKd() const { return velocity_kd_; }
                const FloatField& velocityFeedForward() const { return velocity_feed_forward_; }
                const FloatField& velocityDeadZone() const { return velocity_dead_zone_; }
                const FloatField& velocityIClamp() const { return velocity_i_clamp_; }
                const FloatField& velocityPunch() const { return velocity_punch_; }
                const FloatField& velocityMinTarget() const { return velocity_min_target_; }
                const FloatField& velocityMaxTarget() const { return velocity_max_target_; }
                const FloatField& velocityTargetLowpass() const { return velocity_target_lowpass_; }
                const FloatField& velocityMinOutput() const { return velocity_min_output_; }
                const FloatField& velocityMaxOutput() const { return velocity_max_output_; }
                const FloatField& velocityOutputLowpass() const { return velocity_output_lowpass_; }
                const BoolField& velocityDOnError() const { return velocity_d_on_error_; }
            
              private:
                HebiInfoPtr const internal_;
            
                FloatField velocity_kp_;
                FloatField velocity_ki_;
                FloatField velocity_kd_;
                FloatField velocity_feed_forward_;
                FloatField velocity_dead_zone_;
                FloatField velocity_i_clamp_;
                FloatField velocity_punch_;
                FloatField velocity_min_target_;
                FloatField velocity_max_target_;
                FloatField velocity_target_lowpass_;
                FloatField velocity_min_output_;
                FloatField velocity_max_output_;
                FloatField velocity_output_lowpass_;
                BoolField velocity_d_on_error_;
            
                HEBI_DISABLE_COPY_MOVE(VelocityGains)
            };
        
            class EffortGains final
            {
              public:
                #ifndef DOXYGEN_OMIT_INTERNAL
                EffortGains(HebiInfoPtr internal)
                  : internal_(internal),
                    effort_kp_(internal, HebiInfoFloatEffortKp),
                    effort_ki_(internal, HebiInfoFloatEffortKi),
                    effort_kd_(internal, HebiInfoFloatEffortKd),
                    effort_feed_forward_(internal, HebiInfoFloatEffortFeedForward),
                    effort_dead_zone_(internal, HebiInfoFloatEffortDeadZone),
                    effort_i_clamp_(internal, HebiInfoFloatEffortIClamp),
                    effort_punch_(internal, HebiInfoFloatEffortPunch),
                    effort_min_target_(internal, HebiInfoFloatEffortMinTarget),
                    effort_max_target_(internal, HebiInfoFloatEffortMaxTarget),
                    effort_target_lowpass_(internal, HebiInfoFloatEffortTargetLowpass),
                    effort_min_output_(internal, HebiInfoFloatEffortMinOutput),
                    effort_max_output_(internal, HebiInfoFloatEffortMaxOutput),
                    effort_output_lowpass_(internal, HebiInfoFloatEffortOutputLowpass),
                    effort_d_on_error_(internal, HebiInfoBoolEffortDOnError)
                {
                }
                #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& effortKp() const { return effort_kp_; }
                const FloatField& effortKi() const { return effort_ki_; }
                const FloatField& effortKd() const { return effort_kd_; }
                const FloatField& effortFeedForward() const { return effort_feed_forward_; }
                const FloatField& effortDeadZone() const { return effort_dead_zone_; }
                const FloatField& effortIClamp() const { return effort_i_clamp_; }
                const FloatField& effortPunch() const { return effort_punch_; }
                const FloatField& effortMinTarget() const { return effort_min_target_; }
                const FloatField& effortMaxTarget() const { return effort_max_target_; }
                const FloatField& effortTargetLowpass() const { return effort_target_lowpass_; }
                const FloatField& effortMinOutput() const { return effort_min_output_; }
                const FloatField& effortMaxOutput() const { return effort_max_output_; }
                const FloatField& effortOutputLowpass() const { return effort_output_lowpass_; }
                const BoolField& effortDOnError() const { return effort_d_on_error_; }
            
              private:
                HebiInfoPtr const internal_;
            
                FloatField effort_kp_;
                FloatField effort_ki_;
                FloatField effort_kd_;
                FloatField effort_feed_forward_;
                FloatField effort_dead_zone_;
                FloatField effort_i_clamp_;
                FloatField effort_punch_;
                FloatField effort_min_target_;
                FloatField effort_max_target_;
                FloatField effort_target_lowpass_;
                FloatField effort_min_output_;
                FloatField effort_max_output_;
                FloatField effort_output_lowpass_;
                BoolField effort_d_on_error_;
            
                HEBI_DISABLE_COPY_MOVE(EffortGains)
            };
        
          public:
            #ifndef DOXYGEN_OMIT_INTERNAL
            Actuator(HebiInfoPtr internal)
              : internal_(internal),
                position_gains_(internal),
                velocity_gains_(internal),
                effort_gains_(internal),
                spring_constant_(internal, HebiInfoFloatSpringConstant),
                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 PositionGains& positionGains() const { return position_gains_; }
            const VelocityGains& velocityGains() const { return velocity_gains_; }
            const EffortGains& effortGains() const { return effort_gains_; }
        
            // Subfields ----------------
        
            const FloatField& springConstant() const { return spring_constant_; }
            const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
        
          private:
            HebiInfoPtr const internal_;
        
            PositionGains position_gains_;
            VelocityGains velocity_gains_;
            EffortGains effort_gains_;
        
            FloatField spring_constant_;
            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)
    };

  private:
    HebiInfoPtr internal_;

  public:
    #ifndef DOXYGEN_OMIT_INTERNAL

    Info(HebiInfoPtr );
    #endif // DOXYGEN_OMIT_INTERNAL

    Info(Info&& other);
    virtual ~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_; }

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

    const LedField& led() const;

  private:
    Settings settings_;

    LedField led_;

    HEBI_DISABLE_COPY(Info)

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

} // namespace hebi