
 

// This file is autogenerated. DO NOT EDIT

#pragma once
#include <robotpy_build.h>


#include <../../build/temp.linux-armv7l-3.10/dlstatic/revlib/include/rev/SparkMaxPIDController.h>

#include <rev/CANSparkMax.h>




namespace rpygen {

using namespace rev;



template <typename CfgBase = EmptyTrampolineCfg>
struct PyTrampolineCfg_rev__SparkMaxPIDController :
    CfgBase
{
    using Base = rev::SparkMaxPIDController;

    using override_base_SetP_d_i = rev::SparkMaxPIDController;
    using override_base_SetI_d_i = rev::SparkMaxPIDController;
    using override_base_SetD_d_i = rev::SparkMaxPIDController;
    using override_base_SetDFilter_d_i = rev::SparkMaxPIDController;
    using override_base_SetFF_d_i = rev::SparkMaxPIDController;
    using override_base_SetIZone_d_i = rev::SparkMaxPIDController;
    using override_base_SetOutputRange_d_d_i = rev::SparkMaxPIDController;
    using override_base_KGetP_i = rev::SparkMaxPIDController;
    using override_base_KGetI_i = rev::SparkMaxPIDController;
    using override_base_KGetD_i = rev::SparkMaxPIDController;
    using override_base_KGetDFilter_i = rev::SparkMaxPIDController;
    using override_base_KGetFF_i = rev::SparkMaxPIDController;
    using override_base_KGetIZone_i = rev::SparkMaxPIDController;
    using override_base_KGetOutputMin_i = rev::SparkMaxPIDController;
    using override_base_KGetOutputMax_i = rev::SparkMaxPIDController;
    using override_base_SetSmartMotionMaxVelocity_d_i = rev::SparkMaxPIDController;
    using override_base_SetSmartMotionMaxAccel_d_i = rev::SparkMaxPIDController;
    using override_base_SetSmartMotionMinOutputVelocity_d_i = rev::SparkMaxPIDController;
    using override_base_SetSmartMotionAllowedClosedLoopError_d_i = rev::SparkMaxPIDController;
    using override_base_KGetSmartMotionMaxVelocity_i = rev::SparkMaxPIDController;
    using override_base_KGetSmartMotionMaxAccel_i = rev::SparkMaxPIDController;
    using override_base_KGetSmartMotionMinOutputVelocity_i = rev::SparkMaxPIDController;
    using override_base_KGetSmartMotionAllowedClosedLoopError_i = rev::SparkMaxPIDController;
    using override_base_SetIMaxAccum_d_i = rev::SparkMaxPIDController;
    using override_base_KGetIMaxAccum_i = rev::SparkMaxPIDController;
    using override_base_SetIAccum_d = rev::SparkMaxPIDController;
    using override_base_KGetIAccum_v = rev::SparkMaxPIDController;
    using override_base_SetFeedbackDevice_KRTCANSensor = rev::SparkMaxPIDController;
};


template <typename PyTrampolineBase, typename PyTrampolineCfg>
struct PyTrampoline_rev__SparkMaxPIDController : PyTrampolineBase, virtual py::trampoline_self_life_support {
    using PyTrampolineBase::PyTrampolineBase;


using ArbFFUnits = rev::SparkMaxPIDController::ArbFFUnits;
#ifndef RPYGEN_DISABLE_SetP_d_i
    REVLibError SetP(double gain, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetP_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setP", gain, slotID);
        return CxxCallBase::SetP(gain, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetI_d_i
    REVLibError SetI(double gain, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetI_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setI", gain, slotID);
        return CxxCallBase::SetI(gain, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetD_d_i
    REVLibError SetD(double gain, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetD_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setD", gain, slotID);
        return CxxCallBase::SetD(gain, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetDFilter_d_i
    REVLibError SetDFilter(double gain, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetDFilter_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setDFilter", gain, slotID);
        return CxxCallBase::SetDFilter(gain, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetFF_d_i
    REVLibError SetFF(double gain, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetFF_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setFF", gain, slotID);
        return CxxCallBase::SetFF(gain, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetIZone_d_i
    REVLibError SetIZone(double IZone, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetIZone_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setIZone", IZone, slotID);
        return CxxCallBase::SetIZone(IZone, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetOutputRange_d_d_i
    REVLibError SetOutputRange(double min, double max, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetOutputRange_d_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setOutputRange", min, max, slotID);
        return CxxCallBase::SetOutputRange(min, max, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetP_i
    double GetP(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetP_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getP", slotID);
        return CxxCallBase::GetP(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetI_i
    double GetI(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetI_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getI", slotID);
        return CxxCallBase::GetI(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetD_i
    double GetD(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetD_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getD", slotID);
        return CxxCallBase::GetD(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetDFilter_i
    double GetDFilter(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetDFilter_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getDFilter", slotID);
        return CxxCallBase::GetDFilter(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetFF_i
    double GetFF(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetFF_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getFF", slotID);
        return CxxCallBase::GetFF(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetIZone_i
    double GetIZone(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetIZone_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getIZone", slotID);
        return CxxCallBase::GetIZone(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetOutputMin_i
    double GetOutputMin(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetOutputMin_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getOutputMin", slotID);
        return CxxCallBase::GetOutputMin(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetOutputMax_i
    double GetOutputMax(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetOutputMax_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getOutputMax", slotID);
        return CxxCallBase::GetOutputMax(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetSmartMotionMaxVelocity_d_i
    REVLibError SetSmartMotionMaxVelocity(double maxVel, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetSmartMotionMaxVelocity_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setSmartMotionMaxVelocity", maxVel, slotID);
        return CxxCallBase::SetSmartMotionMaxVelocity(maxVel, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetSmartMotionMaxAccel_d_i
    REVLibError SetSmartMotionMaxAccel(double maxAccel, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetSmartMotionMaxAccel_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setSmartMotionMaxAccel", maxAccel, slotID);
        return CxxCallBase::SetSmartMotionMaxAccel(maxAccel, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetSmartMotionMinOutputVelocity_d_i
    REVLibError SetSmartMotionMinOutputVelocity(double minVel, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetSmartMotionMinOutputVelocity_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setSmartMotionMinOutputVelocity", minVel, slotID);
        return CxxCallBase::SetSmartMotionMinOutputVelocity(minVel, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetSmartMotionAllowedClosedLoopError_d_i
    REVLibError SetSmartMotionAllowedClosedLoopError(double allowedErr, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetSmartMotionAllowedClosedLoopError_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setSmartMotionAllowedClosedLoopError", allowedErr, slotID);
        return CxxCallBase::SetSmartMotionAllowedClosedLoopError(allowedErr, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetSmartMotionMaxVelocity_i
    double GetSmartMotionMaxVelocity(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetSmartMotionMaxVelocity_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getSmartMotionMaxVelocity", slotID);
        return CxxCallBase::GetSmartMotionMaxVelocity(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetSmartMotionMaxAccel_i
    double GetSmartMotionMaxAccel(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetSmartMotionMaxAccel_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getSmartMotionMaxAccel", slotID);
        return CxxCallBase::GetSmartMotionMaxAccel(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetSmartMotionMinOutputVelocity_i
    double GetSmartMotionMinOutputVelocity(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetSmartMotionMinOutputVelocity_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getSmartMotionMinOutputVelocity", slotID);
        return CxxCallBase::GetSmartMotionMinOutputVelocity(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetSmartMotionAllowedClosedLoopError_i
    double GetSmartMotionAllowedClosedLoopError(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetSmartMotionAllowedClosedLoopError_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getSmartMotionAllowedClosedLoopError", slotID);
        return CxxCallBase::GetSmartMotionAllowedClosedLoopError(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetIMaxAccum_d_i
    REVLibError SetIMaxAccum(double iMaxAccum, int slotID) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetIMaxAccum_d_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setIMaxAccum", iMaxAccum, slotID);
        return CxxCallBase::SetIMaxAccum(iMaxAccum, slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetIMaxAccum_i
    double GetIMaxAccum(int slotID) const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetIMaxAccum_i;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getIMaxAccum", slotID);
        return CxxCallBase::GetIMaxAccum(slotID);
    }
#endif

#ifndef RPYGEN_DISABLE_SetIAccum_d
    REVLibError SetIAccum(double iAccum) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetIAccum_d;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setIAccum", iAccum);
        return CxxCallBase::SetIAccum(iAccum);
    }
#endif

#ifndef RPYGEN_DISABLE_KGetIAccum_v
    double GetIAccum() const override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_KGetIAccum_v;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(double), LookupBase,
            "getIAccum", );
        return CxxCallBase::GetIAccum();
    }
#endif

#ifndef RPYGEN_DISABLE_SetFeedbackDevice_KRTCANSensor
    REVLibError SetFeedbackDevice(const CANSensor& sensor) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_SetFeedbackDevice_KRTCANSensor;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(REVLibError), LookupBase,
            "setFeedbackDevice", sensor);
        return CxxCallBase::SetFeedbackDevice(sensor);
    }
#endif




};

}; // namespace rpygen
