command.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 Command final
{
  public:
    enum class 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(size_t fieldNumber) const;
        float get(size_t fieldNumber) const;
        void set(size_t fieldNumber, float value);
        void clear(size_t 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 <typename 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 { int32_t ret{}; hebiCommandGetEnum(internal_, field_, &ret); return static_cast<T>(ret); }
        void set(T _value) { int32_t value = static_cast<int32_t>(_value); hebiCommandSetEnum(internal_, field_, &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(size_t pinNumber) const;
        bool hasFloat(size_t pinNumber) const;
        int64_t getInt(size_t pinNumber) const;
        float getFloat(size_t pinNumber) const;
        void setInt(size_t pinNumber, int64_t value);
        void setFloat(size_t pinNumber, float value);
        void clear(size_t 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 has() const;
        Color get() const;
        void set(const Color& color);
        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)
    };

    using CommandGains = Gains<HebiCommandPtr, FloatField, BoolField, HebiCommandFloatField, HebiCommandBoolField>;

    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(HebiCommandPtr internal)
              : internal_(internal),
                position_gains_(internal, HebiCommandFloatPositionKp, HebiCommandBoolPositionDOnError),
                velocity_gains_(internal, HebiCommandFloatVelocityKp, HebiCommandBoolVelocityDOnError),
                effort_gains_(internal, HebiCommandFloatEffortKp, HebiCommandBoolEffortDOnError),
                spring_constant_(internal, HebiCommandFloatSpringConstant),
                reference_position_(internal, HebiCommandFloatReferencePosition),
                reference_effort_(internal, HebiCommandFloatReferenceEffort),
                position_limit_min_(internal, HebiCommandHighResAnglePositionLimitMin),
                position_limit_max_(internal, HebiCommandHighResAnglePositionLimitMax),
                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 ----------------
        
            CommandGains& positionGains() { return position_gains_; }
            const CommandGains& positionGains() const { return position_gains_; }
            CommandGains& velocityGains() { return velocity_gains_; }
            const CommandGains& velocityGains() const { return velocity_gains_; }
            CommandGains& effortGains() { return effort_gains_; }
            const CommandGains& effortGains() const { return effort_gains_; }
        
            // Subfields ----------------
        
            FloatField& springConstant() { return spring_constant_; }
            const FloatField& springConstant() const { return spring_constant_; }
            FloatField& referencePosition() { return reference_position_; }
            const FloatField& referencePosition() const { return reference_position_; }
            FloatField& referenceEffort() { return reference_effort_; }
            const FloatField& referenceEffort() const { return reference_effort_; }
            HighResAngleField& positionLimitMin() { return position_limit_min_; }
            const HighResAngleField& positionLimitMin() const { return position_limit_min_; }
            HighResAngleField& positionLimitMax() { return position_limit_max_; }
            const HighResAngleField& positionLimitMax() const { return position_limit_max_; }
            EnumField<ControlStrategy>& controlStrategy() { return control_strategy_; }
            const EnumField<ControlStrategy>& controlStrategy() const { return control_strategy_; }
        
          private:
            HebiCommandPtr const internal_;
        
            CommandGains position_gains_;
            CommandGains velocity_gains_;
            CommandGains effort_gains_;
        
            FloatField spring_constant_;
            FloatField reference_position_;
            FloatField reference_effort_;
            HighResAngleField position_limit_min_;
            HighResAngleField position_limit_max_;
            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);
    ~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
    FlagField& reset();
    const FlagField& reset() const;
    FlagField& boot();
    const FlagField& boot() const;
    FlagField& stopBoot();
    const FlagField& stopBoot() const;
    LedField& led();
    const LedField& led() const;

  private:
    Io io_;
    Settings settings_;
    Actuator actuator_;

    NumberedFloatField debug_;
    FlagField reset_;
    FlagField boot_;
    FlagField stop_boot_;
    LedField led_;

    HEBI_DISABLE_COPY(Command)

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

} // namespace hebi