PIDController.h

#pragma once
#include <frc/controller/PIDController.h>
 
#include "valkyrie/Robot.h"
#include "valkyrie/controllers/PIDF.h"
 
namespace valor {

template <typename INPUT, typename OUTPUT>
class PIDController : public frc::PIDController {
   public:
    using ErrorDerivative = units::unit_t<units::compound_unit<INPUT, units::inverse<units::second>>>;

    constexpr PIDController(const PIDF<INPUT, OUTPUT>& pidf, units::second_t period = Robot::kDefaultPeriod)
          : frc::PIDController{pidf.P.value(), pidf.I.value(), pidf.D.value(), period}, pidf{pidf} {
        SetTolerance(pidf.error, GetErrorDerivativeTolerance());
    }

    constexpr void SetPID(const PIDF<INPUT, OUTPUT>& pidf) {
        this->pidf = pidf;
        frc::PIDController::SetPID(pidf.P.value(), pidf.I.value(), pidf.D.value());
        SetTolerance(pidf.error, GetErrorDerivativeTolerance());
    }

    constexpr void SetP(PIDF<INPUT, OUTPUT>::ProportionalGain_t Kp) {
        pidf.P = Kp;
        frc::PIDController::SetP(Kp.value());
    }

    constexpr void SetI(PIDF<INPUT, OUTPUT>::IntegralGain_t Ki) {
        pidf.I = Ki;
        frc::PIDController::SetI(Ki.value());
    }

    constexpr void SetD(PIDF<INPUT, OUTPUT>::DerivativeGain_t Kd) {
        pidf.D = Kd;
        frc::PIDController::SetD(Kd.value());
    }

    constexpr void SetIZone(PIDF<INPUT, OUTPUT>::Output_t iZone) { frc::PIDController::SetIZone(iZone.value()); }

    constexpr PIDF<INPUT, OUTPUT>::ProportionalGain_t GetP() const {
        return typename PIDF<INPUT, OUTPUT>::ProportionalGain_t{frc::PIDController::GetP()};
    }

    constexpr PIDF<INPUT, OUTPUT>::IntegralGain_t GetI() const {
        return typename PIDF<INPUT, OUTPUT>::IntegralGain_t{frc::PIDController::GetI()};
    }

    constexpr PIDF<INPUT, OUTPUT>::DerivativeGain_t GetD() const {
        return typename PIDF<INPUT, OUTPUT>::DerivativeGain_t{frc::PIDController::GetD()};
    }

    constexpr PIDF<INPUT, OUTPUT>::Output_t GetIZone() const {
        return typename PIDF<INPUT, OUTPUT>::Output_t{frc::PIDController::GetIZone()};
    }

    constexpr PIDF<INPUT, OUTPUT>::Input_t GetErrorTolerance() const {
        return typename PIDF<INPUT, OUTPUT>::Input_t{frc::PIDController::GetErrorTolerance()};
    }

    constexpr ErrorDerivative GetErrorDerivativeTolerance() const {
        return ErrorDerivative{frc::PIDController::GetErrorDerivativeTolerance()};
    }

    constexpr PIDF<INPUT, OUTPUT>::Input_t GetAccumulatedError() const {
        return typename PIDF<INPUT, OUTPUT>::Input_t{frc::PIDController::GetAccumulatedError()};
    }

    constexpr void SetSetpoint(PIDF<INPUT, OUTPUT>::Input_t setpoint) { frc::PIDController::SetSetpoint(setpoint.value()); }

    constexpr PIDF<INPUT, OUTPUT>::Input_t GetSetpoint() const {
        return typename PIDF<INPUT, OUTPUT>::Input_t{frc::PIDController::GetSetpoint()};
    }

    constexpr void EnableContinuousInput(PIDF<INPUT, OUTPUT>::Input_t minimumInput, PIDF<INPUT, OUTPUT>::Input_t maximumInput) {
        frc::PIDController::EnableContinuousInput(minimumInput.value(), maximumInput.value());
    }

    constexpr void SetIntegratorRange(PIDF<INPUT, OUTPUT>::Output_t minimumIntegral, PIDF<INPUT, OUTPUT>::Output_t maximumIntegral) {
        frc::PIDController::SetIntegratorRange(minimumIntegral.value(), maximumIntegral.value());
    }

    constexpr void SetTolerance(PIDF<INPUT, OUTPUT>::Input_t errorTolerance,
                                ErrorDerivative errorDerivativeTolerance = ErrorDerivative{std::numeric_limits<double>::infinity()}) {
        pidf.error = errorTolerance;
        frc::PIDController::SetTolerance(errorTolerance.value(), errorDerivativeTolerance.value());
    }

    constexpr PIDF<INPUT, OUTPUT>::Input_t GetError() const {
        return typename PIDF<INPUT, OUTPUT>::Input_t{frc::PIDController::GetError()};
    }

    constexpr ErrorDerivative GetErrorDerivative() const { return ErrorDerivative{frc::PIDController::GetErrorDerivative()}; }

    constexpr const valor::PIDF<INPUT, OUTPUT>& GetPID() const { return pidf; }

    constexpr PIDF<INPUT, OUTPUT>::Output_t Calculate(PIDF<INPUT, OUTPUT>::Input_t measurement) {
        typename PIDF<INPUT, OUTPUT>::Output_t output{frc::PIDController::Calculate(measurement.value())};
        if constexpr (std::is_same_v<decltype(measurement), typename PIDF<INPUT, OUTPUT>::Velocity_t>)
            if (pidf.kV)
                output += *pidf.kV * measurement;
        output += pidf.kS;
        if (pidf.GType == GravityFFType::LINEAR)
            output += pidf.kG;
        else if constexpr (std::is_convertible_v<decltype(measurement), units::turn_t>)
            if (pidf.GType == GravityFFType::CIRCULAR)
                output += pidf.kG * units::math::cos(measurement + pidf.GTarget);
        return output;
    }

    constexpr PIDF<INPUT, OUTPUT>::Output_t Calculate(PIDF<INPUT, OUTPUT>::Input_t measurement, PIDF<INPUT, OUTPUT>::Input_t setpoint) {
        SetSetpoint(setpoint);
        return Calculate(measurement);
    }
 
   private:
    PIDF<INPUT, OUTPUT> pidf;
};
 
}  // namespace valor