command.hpp

Go to the documentation of this file.

#pragma once

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

namespace hebi {

class Command 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(HebiCommandPtr internal, HebiCommandFloatField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        float get() const;
        void set(float value);
        void clear();

      private:
        HebiCommandPtr const internal_;
        HebiCommandFloatField const field_;

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

      private:
        HebiCommandPtr const internal_;
        HebiCommandHighResAngleField const field_;

        HEBI_DISABLE_COPY_MOVE(HighResAngleField)
    };

    class NumberedFloatField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        NumberedFloatField(HebiCommandPtr internal, HebiCommandNumberedFloatField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool has(int fieldNumber) const;
        float get(int fieldNumber) const;
        void set(int fieldNumber, float value);
        void clear(int fieldNumber);

      private:
        HebiCommandPtr const internal_;
        HebiCommandNumberedFloatField const field_;

        HEBI_DISABLE_COPY_MOVE(NumberedFloatField)
    };

    class BoolField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        BoolField(HebiCommandPtr internal, HebiCommandBoolField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool has() const;
        bool get() const;
        void set(bool value);
        void clear();

      private:
        HebiCommandPtr const internal_;
        HebiCommandBoolField const field_;

        HEBI_DISABLE_COPY_MOVE(BoolField)
    };

    class StringField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        StringField(HebiCommandPtr internal, HebiCommandStringField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        std::string get() const;
        void set(const std::string& value);
        void clear();

      private:
        HebiCommandPtr const internal_;
        HebiCommandStringField const field_;

        HEBI_DISABLE_COPY_MOVE(StringField)
    };

    class FlagField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        FlagField(HebiCommandPtr internal, HebiCommandFlagField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const;
        bool has() const;
        void set();
        void clear();

      private:
        HebiCommandPtr const internal_;
        HebiCommandFlagField const field_;

        HEBI_DISABLE_COPY_MOVE(FlagField)
    };

    template <class T>
    class EnumField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        EnumField(HebiCommandPtr internal, HebiCommandEnumField field)
          : internal_(internal), field_(field) {}
        #endif // DOXYGEN_OMIT_INTERNAL
        explicit operator bool() const { return has(); }
        bool has() const { return (hebiCommandGetEnum(internal_, field_, nullptr) == HebiStatusSuccess); }
        T get() const { T ret; hebiCommandGetEnum(internal_, field_, reinterpret_cast<int*>(&ret)); return ret; }
        void set(T value) { hebiCommandSetEnum(internal_, field_, reinterpret_cast<int*>(&value)); }
        void clear() { hebiCommandSetEnum(internal_, field_, nullptr); }

      private:
        HebiCommandPtr const internal_;
        HebiCommandEnumField const field_;

        HEBI_DISABLE_COPY_MOVE(EnumField)
    };

    class IoBank final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        IoBank(HebiCommandPtr internal, HebiCommandIoPinBank bank);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool hasInt(int pinNumber) const;
        bool hasFloat(int pinNumber) const;
        int64_t getInt(int pinNumber) const;
        float getFloat(int pinNumber) const;
        void setInt(int pinNumber, int64_t value);
        void setFloat(int pinNumber, float value);
        void clear(int pinNumber);

      private:
        HebiCommandPtr const internal_;
        HebiCommandIoPinBank const bank_;

        HEBI_DISABLE_COPY_MOVE(IoBank);
    };
    class LedField final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        LedField(HebiCommandPtr internal, HebiCommandLedField field);
        #endif // DOXYGEN_OMIT_INTERNAL
        bool hasColor() const;
        bool hasModuleControl() const;
        Color getColor() const;
        void setOverrideColor(const Color& new_color);
        void setModuleControl();
        void clear();

      private:
        HebiCommandPtr const internal_;
        HebiCommandLedField const field_;

        HEBI_DISABLE_COPY_MOVE(LedField)
    };

    class Io final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Io(HebiCommandPtr internal)
          : internal_(internal),
            a_(internal, HebiCommandIoBankA),
            b_(internal, HebiCommandIoBankB),
            c_(internal, HebiCommandIoBankC),
            d_(internal, HebiCommandIoBankD),
            e_(internal, HebiCommandIoBankE),
            f_(internal, HebiCommandIoBankF)
        {
        }
        #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_; }
    
      private:
        HebiCommandPtr const internal_;
    
        IoBank a_;
        IoBank b_;
        IoBank c_;
        IoBank d_;
        IoBank e_;
        IoBank f_;
    
        HEBI_DISABLE_COPY_MOVE(Io)
    };

    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(HebiCommandPtr internal)
                  : internal_(internal),
                    position_kp_(internal, HebiCommandFloatPositionKp),
                    position_ki_(internal, HebiCommandFloatPositionKi),
                    position_kd_(internal, HebiCommandFloatPositionKd),
                    position_feed_forward_(internal, HebiCommandFloatPositionFeedForward),
                    position_dead_zone_(internal, HebiCommandFloatPositionDeadZone),
                    position_i_clamp_(internal, HebiCommandFloatPositionIClamp),
                    position_punch_(internal, HebiCommandFloatPositionPunch),
                    position_min_target_(internal, HebiCommandFloatPositionMinTarget),
                    position_max_target_(internal, HebiCommandFloatPositionMaxTarget),
                    position_target_lowpass_(internal, HebiCommandFloatPositionTargetLowpass),
                    position_min_output_(internal, HebiCommandFloatPositionMinOutput),
                    position_max_output_(internal, HebiCommandFloatPositionMaxOutput),
                    position_output_lowpass_(internal, HebiCommandFloatPositionOutputLowpass),
                    position_d_on_error_(internal, HebiCommandBoolPositionDOnError)
                {
                }
                #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 ----------------
            
                FloatField& positionKp() { return position_kp_; }
                const FloatField& positionKp() const { return position_kp_; }
                FloatField& positionKi() { return position_ki_; }
                const FloatField& positionKi() const { return position_ki_; }
                FloatField& positionKd() { return position_kd_; }
                const FloatField& positionKd() const { return position_kd_; }
                FloatField& positionFeedForward() { return position_feed_forward_; }
                const FloatField& positionFeedForward() const { return position_feed_forward_; }
                FloatField& positionDeadZone() { return position_dead_zone_; }
                const FloatField& positionDeadZone() const { return position_dead_zone_; }
                FloatField& positionIClamp() { return position_i_clamp_; }
                const FloatField& positionIClamp() const { return position_i_clamp_; }
                FloatField& positionPunch() { return position_punch_; }
                const FloatField& positionPunch() const { return position_punch_; }
                FloatField& positionMinTarget() { return position_min_target_; }
                const FloatField& positionMinTarget() const { return position_min_target_; }
                FloatField& positionMaxTarget() { return position_max_target_; }
                const FloatField& positionMaxTarget() const { return position_max_target_; }
                FloatField& positionTargetLowpass() { return position_target_lowpass_; }
                const FloatField& positionTargetLowpass() const { return position_target_lowpass_; }
                FloatField& positionMinOutput() { return position_min_output_; }
                const FloatField& positionMinOutput() const { return position_min_output_; }
                FloatField& positionMaxOutput() { return position_max_output_; }
                const FloatField& positionMaxOutput() const { return position_max_output_; }
                FloatField& positionOutputLowpass() { return position_output_lowpass_; }
                const FloatField& positionOutputLowpass() const { return position_output_lowpass_; }
                BoolField& positionDOnError() { return position_d_on_error_; }
                const BoolField& positionDOnError() const { return position_d_on_error_; }
            
              private:
                HebiCommandPtr 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(HebiCommandPtr internal)
                  : internal_(internal),
                    velocity_kp_(internal, HebiCommandFloatVelocityKp),
                    velocity_ki_(internal, HebiCommandFloatVelocityKi),
                    velocity_kd_(internal, HebiCommandFloatVelocityKd),
                    velocity_feed_forward_(internal, HebiCommandFloatVelocityFeedForward),
                    velocity_dead_zone_(internal, HebiCommandFloatVelocityDeadZone),
                    velocity_i_clamp_(internal, HebiCommandFloatVelocityIClamp),
                    velocity_punch_(internal, HebiCommandFloatVelocityPunch),
                    velocity_min_target_(internal, HebiCommandFloatVelocityMinTarget),
                    velocity_max_target_(internal, HebiCommandFloatVelocityMaxTarget),
                    velocity_target_lowpass_(internal, HebiCommandFloatVelocityTargetLowpass),
                    velocity_min_output_(internal, HebiCommandFloatVelocityMinOutput),
                    velocity_max_output_(internal, HebiCommandFloatVelocityMaxOutput),
                    velocity_output_lowpass_(internal, HebiCommandFloatVelocityOutputLowpass),
                    velocity_d_on_error_(internal, HebiCommandBoolVelocityDOnError)
                {
                }
                #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 ----------------
            
                FloatField& velocityKp() { return velocity_kp_; }
                const FloatField& velocityKp() const { return velocity_kp_; }
                FloatField& velocityKi() { return velocity_ki_; }
                const FloatField& velocityKi() const { return velocity_ki_; }
                FloatField& velocityKd() { return velocity_kd_; }
                const FloatField& velocityKd() const { return velocity_kd_; }
                FloatField& velocityFeedForward() { return velocity_feed_forward_; }
                const FloatField& velocityFeedForward() const { return velocity_feed_forward_; }
                FloatField& velocityDeadZone() { return velocity_dead_zone_; }
                const FloatField& velocityDeadZone() const { return velocity_dead_zone_; }
                FloatField& velocityIClamp() { return velocity_i_clamp_; }
                const FloatField& velocityIClamp() const { return velocity_i_clamp_; }
                FloatField& velocityPunch() { return velocity_punch_; }
                const FloatField& velocityPunch() const { return velocity_punch_; }
                FloatField& velocityMinTarget() { return velocity_min_target_; }
                const FloatField& velocityMinTarget() const { return velocity_min_target_; }
                FloatField& velocityMaxTarget() { return velocity_max_target_; }
                const FloatField& velocityMaxTarget() const { return velocity_max_target_; }
                FloatField& velocityTargetLowpass() { return velocity_target_lowpass_; }
                const FloatField& velocityTargetLowpass() const { return velocity_target_lowpass_; }
                FloatField& velocityMinOutput() { return velocity_min_output_; }
                const FloatField& velocityMinOutput() const { return velocity_min_output_; }
                FloatField& velocityMaxOutput() { return velocity_max_output_; }
                const FloatField& velocityMaxOutput() const { return velocity_max_output_; }
                FloatField& velocityOutputLowpass() { return velocity_output_lowpass_; }
                const FloatField& velocityOutputLowpass() const { return velocity_output_lowpass_; }
                BoolField& velocityDOnError() { return velocity_d_on_error_; }
                const BoolField& velocityDOnError() const { return velocity_d_on_error_; }
            
              private:
                HebiCommandPtr 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(HebiCommandPtr internal)
                  : internal_(internal),
                    effort_kp_(internal, HebiCommandFloatEffortKp),
                    effort_ki_(internal, HebiCommandFloatEffortKi),
                    effort_kd_(internal, HebiCommandFloatEffortKd),
                    effort_feed_forward_(internal, HebiCommandFloatEffortFeedForward),
                    effort_dead_zone_(internal, HebiCommandFloatEffortDeadZone),
                    effort_i_clamp_(internal, HebiCommandFloatEffortIClamp),
                    effort_punch_(internal, HebiCommandFloatEffortPunch),
                    effort_min_target_(internal, HebiCommandFloatEffortMinTarget),
                    effort_max_target_(internal, HebiCommandFloatEffortMaxTarget),
                    effort_target_lowpass_(internal, HebiCommandFloatEffortTargetLowpass),
                    effort_min_output_(internal, HebiCommandFloatEffortMinOutput),
                    effort_max_output_(internal, HebiCommandFloatEffortMaxOutput),
                    effort_output_lowpass_(internal, HebiCommandFloatEffortOutputLowpass),
                    effort_d_on_error_(internal, HebiCommandBoolEffortDOnError)
                {
                }
                #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 ----------------
            
                FloatField& effortKp() { return effort_kp_; }
                const FloatField& effortKp() const { return effort_kp_; }
                FloatField& effortKi() { return effort_ki_; }
                const FloatField& effortKi() const { return effort_ki_; }
                FloatField& effortKd() { return effort_kd_; }
                const FloatField& effortKd() const { return effort_kd_; }
                FloatField& effortFeedForward() { return effort_feed_forward_; }
                const FloatField& effortFeedForward() const { return effort_feed_forward_; }
                FloatField& effortDeadZone() { return effort_dead_zone_; }
                const FloatField& effortDeadZone() const { return effort_dead_zone_; }
                FloatField& effortIClamp() { return effort_i_clamp_; }
                const FloatField& effortIClamp() const { return effort_i_clamp_; }
                FloatField& effortPunch() { return effort_punch_; }
                const FloatField& effortPunch() const { return effort_punch_; }
                FloatField& effortMinTarget() { return effort_min_target_; }
                const FloatField& effortMinTarget() const { return effort_min_target_; }
                FloatField& effortMaxTarget() { return effort_max_target_; }
                const FloatField& effortMaxTarget() const { return effort_max_target_; }
                FloatField& effortTargetLowpass() { return effort_target_lowpass_; }
                const FloatField& effortTargetLowpass() const { return effort_target_lowpass_; }
                FloatField& effortMinOutput() { return effort_min_output_; }
                const FloatField& effortMinOutput() const { return effort_min_output_; }
                FloatField& effortMaxOutput() { return effort_max_output_; }
                const FloatField& effortMaxOutput() const { return effort_max_output_; }
                FloatField& effortOutputLowpass() { return effort_output_lowpass_; }
                const FloatField& effortOutputLowpass() const { return effort_output_lowpass_; }
                BoolField& effortDOnError() { return effort_d_on_error_; }
                const BoolField& effortDOnError() const { return effort_d_on_error_; }
            
              private:
                HebiCommandPtr 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(HebiCommandPtr internal)
              : internal_(internal),
                position_gains_(internal),
                velocity_gains_(internal),
                effort_gains_(internal),
                spring_constant_(internal, HebiCommandFloatSpringConstant),
                control_strategy_(internal, HebiCommandEnumControlStrategy)
            {
            }
            #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 ----------------
        
            PositionGains& positionGains() { return position_gains_; }
            const PositionGains& positionGains() const { return position_gains_; }
            VelocityGains& velocityGains() { return velocity_gains_; }
            const VelocityGains& velocityGains() const { return velocity_gains_; }
            EffortGains& effortGains() { return effort_gains_; }
            const EffortGains& effortGains() const { return effort_gains_; }
        
            // Subfields ----------------
        
            FloatField& springConstant() { return spring_constant_; }
            const FloatField& springConstant() const { return spring_constant_; }
            EnumField<ControlStrategy>& controlStrategy() { return control_strategy_; }
            const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
        
          private:
            HebiCommandPtr 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(HebiCommandPtr internal)
          : internal_(internal),
            actuator_(internal),
            name_(internal, HebiCommandStringName),
            family_(internal, HebiCommandStringFamily),
            save_current_settings_(internal, HebiCommandFlagSaveCurrentSettings)
        {
        }
        #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 ----------------
    
        Actuator& actuator() { return actuator_; }
        const Actuator& actuator() const { return actuator_; }
    
        // Subfields ----------------
    
        StringField& name() { return name_; }
        const StringField& name() const { return name_; }
        StringField& family() { return family_; }
        const StringField& family() const { return family_; }
        FlagField& saveCurrentSettings() { return save_current_settings_; }
        const FlagField& saveCurrentSettings() const { return save_current_settings_; }
    
      private:
        HebiCommandPtr 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(HebiCommandPtr internal)
          : internal_(internal),
            velocity_(internal, HebiCommandFloatVelocity),
            effort_(internal, HebiCommandFloatEffort),
            position_(internal, HebiCommandHighResAnglePosition)
        {
        }
        #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 ----------------
    
        FloatField& velocity() { return velocity_; }
        const FloatField& velocity() const { return velocity_; }
        FloatField& effort() { return effort_; }
        const FloatField& effort() const { return effort_; }
        HighResAngleField& position() { return position_; }
        const HighResAngleField& position() const { return position_; }
    
      private:
        HebiCommandPtr const internal_;
    
        FloatField velocity_;
        FloatField effort_;
        HighResAngleField position_;
    
        HEBI_DISABLE_COPY_MOVE(Actuator)
    };

  private:
    HebiCommandPtr internal_;

  public:
    #ifndef DOXYGEN_OMIT_INTERNAL

    Command(HebiCommandPtr );
    #endif // DOXYGEN_OMIT_INTERNAL

    Command(Command&& other);
    virtual ~Command() 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 -------------------------------------------------------------

    Io& io() { return io_; }
    const Io& io() const { return io_; }
    Settings& settings() { return settings_; }
    const Settings& settings() const { return settings_; }
    Actuator& actuator() { return actuator_; }
    const Actuator& actuator() const { return actuator_; }

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

    #ifndef DOXYGEN_OMIT_INTERNAL
    NumberedFloatField& debug();
    const NumberedFloatField& debug() const;
    #endif // DOXYGEN_OMIT_INTERNAL
    LedField& led();
    const LedField& led() const;

  private:
    Io io_;
    Settings settings_;
    Actuator actuator_;

    NumberedFloatField debug_;
    LedField led_;

    HEBI_DISABLE_COPY(Command)

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

} // namespace hebi