gains.hpp

Go to the documentation of this file.

#pragma once

#include "util.hpp"

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