feedback.hpp

Go to the documentation of this file.

#pragma once

#include "hebi_feedback.h"
#include "color.hpp"
#include "vector_3_f.hpp"
#include "util.hpp"

namespace hebi {

class Feedback final
{
  // 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(int fieldNumber) const;
        float get(int 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 IoBank final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        IoBank(HebiFeedbackPtr internal, HebiFeedbackIoPinBank 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;

      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)
        {
        }
        #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_; }
    
      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_;
    
        HEBI_DISABLE_COPY_MOVE(Actuator)
    };

    class Imu final
    {
      public:
        #ifndef DOXYGEN_OMIT_INTERNAL
        Imu(HebiFeedbackPtr internal)
          : internal_(internal),
            accelerometer_(internal, HebiFeedbackVector3fAccelerometer),
            gyro_(internal, HebiFeedbackVector3fGyro)
        {
        }
        #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_; }
    
      private:
        HebiFeedbackPtr const internal_;
    
        Vector3fField accelerometer_;
        Vector3fField gyro_;
    
        HEBI_DISABLE_COPY_MOVE(Imu)
    };

  private:
    HebiFeedbackPtr internal_;

  public:
    #ifndef DOXYGEN_OMIT_INTERNAL

    Feedback(HebiFeedbackPtr );
    #endif // DOXYGEN_OMIT_INTERNAL

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