gains.hpp

Go to the documentation of this file.

#pragma once

namespace hebi {

template<typename MessageType,
         typename FloatFieldType, typename BoolFieldType,
         typename FloatEnumType, typename BoolEnumType>
class Gains final
{
  public:
    #ifndef DOXYGEN_OMIT_INTERNAL
    Gains(MessageType internal, FloatEnumType kp_gain, BoolEnumType d_on_error_gain)
      : internal_(internal),
        kp_(internal, kp_gain),
        ki_(internal, static_cast<FloatEnumType>(kp_gain + 1)),
        kd_(internal, static_cast<FloatEnumType>(kp_gain + 2)),
        feed_forward_(internal, static_cast<FloatEnumType>(kp_gain + 3)),
        dead_zone_(internal, static_cast<FloatEnumType>(kp_gain + 4)),
        i_clamp_(internal, static_cast<FloatEnumType>(kp_gain + 5)),
        punch_(internal, static_cast<FloatEnumType>(kp_gain + 6)),
        min_target_(internal, static_cast<FloatEnumType>(kp_gain + 7)),
        max_target_(internal, static_cast<FloatEnumType>(kp_gain + 8)),
        target_lowpass_(internal, static_cast<FloatEnumType>(kp_gain + 9)),
        min_output_(internal, static_cast<FloatEnumType>(kp_gain + 10)),
        max_output_(internal, static_cast<FloatEnumType>(kp_gain + 11)),
        output_lowpass_(internal, static_cast<FloatEnumType>(kp_gain + 12)),
        d_on_error_(internal, d_on_error_gain)
    {
    }
    #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 ----------------

    FloatFieldType& kP() { return kp_; }
    const FloatFieldType& kP() const { return kp_; }
    FloatFieldType& kI() { return ki_; }
    const FloatFieldType& kI() const { return ki_; }
    FloatFieldType& kD() { return kd_; }
    const FloatFieldType& kD() const { return kd_; }
    FloatFieldType& feedForward() { return feed_forward_; }
    const FloatFieldType& feedForward() const { return feed_forward_; }
    FloatFieldType& deadZone() { return dead_zone_; }
    const FloatFieldType& deadZone() const { return dead_zone_; }
    FloatFieldType& iClamp() { return i_clamp_; }
    const FloatFieldType& iClamp() const { return i_clamp_; }
    FloatFieldType& punch() { return punch_; }
    const FloatFieldType& punch() const { return punch_; }
    FloatFieldType& minTarget() { return min_target_; }
    const FloatFieldType& minTarget() const { return min_target_; }
    FloatFieldType& maxTarget() { return max_target_; }
    const FloatFieldType& maxTarget() const { return max_target_; }
    FloatFieldType& targetLowpass() { return target_lowpass_; }
    const FloatFieldType& targetLowpass() const { return target_lowpass_; }
    FloatFieldType& minOutput() { return min_output_; }
    const FloatFieldType& minOutput() const { return min_output_; }
    FloatFieldType& maxOutput() { return max_output_; }
    const FloatFieldType& maxOutput() const { return max_output_; }
    FloatFieldType& outputLowpass() { return output_lowpass_; }
    const FloatFieldType& outputLowpass() const { return output_lowpass_; }
    BoolFieldType& dOnError() { return d_on_error_; }
    const BoolFieldType& dOnError() const { return d_on_error_; }
            
  private:
    MessageType const internal_;

    FloatFieldType kp_;
    FloatFieldType ki_;
    FloatFieldType kd_;
    FloatFieldType feed_forward_;
    FloatFieldType dead_zone_;
    FloatFieldType i_clamp_;
    FloatFieldType punch_;
    FloatFieldType min_target_;
    FloatFieldType max_target_;
    FloatFieldType target_lowpass_;
    FloatFieldType min_output_;
    FloatFieldType max_output_;
    FloatFieldType output_lowpass_;
    BoolFieldType d_on_error_;

    HEBI_DISABLE_COPY_MOVE(Gains)
};

} // namespace hebi