NeoController.h

#pragma once
 
#include <memory>
#include <string>
 
#include <rev/SparkMax.h>
#include <rev/config/SparkMaxConfig.h>
#include <rev/sim/SparkMaxSim.h>
#include <units/base.h>
#include <valkyrie/controllers/BaseController.h>
 
namespace valor {
 
enum NeoControllerType { NEO, NEO_550 };
 
class NeoController : public BaseController, public rev::spark::SparkMax {
   public:
    NeoController(valor::NeoControllerType, int canID, valor::NeutralMode mode, bool inverted);
 
    static constexpr frc::DCMotor getMotorSpec(NeoControllerType controllerType) {
        switch (controllerType) {
            case NEO_550:
                return frc::DCMotor::NEO550();
            default:
                return frc::DCMotor::NEO();
        }
    }
 
    void ApplyConfig() override;
 
    Signal<units::turn_t> GetPosition() const override;
 
    Signal<units::ampere_t> GetCurrent() const override;
 
    Signal<units::volt_t> GetVoltage() const override;
 
    Signal<units::turns_per_second_t> GetSpeed() const override;
 
    Signal<units::turns_per_second_squared_t> GetAcceleration() const override;
 
    void SetEncoderPosition(units::turn_t position) override;
 
    units::turn_t GetAbsoluteEncoderPosition() const override;
 
    void SetContinuousWrap(bool wrap, bool saveImmediately = false);
 
    void PositionSetter(units::turn_t positon, Output feedforward, int slot = 0) override;
    void SpeedSetter(units::turns_per_second_t speed, Output feedforward, int slot = 0) override;
 
    void SetupFollower(int canID, bool followerInverted = false) override;
 
    void SetPIDF(valor::PIDF<> pidf, int slot = 0, bool saveImmediately = false) override;
 
    void SetForwardLimit(units::turn_t forward, bool saveImmediately = false) override;
 
    void SetReverseLimit(units::turn_t reverse, bool saveImmediately = false) override;
 
    void SetGearRatios(double rotorToSensor, double sensorToMech, bool saveImmediately = false) override;
 
    void SetCurrentLimits(units::ampere_t statorCurrentLimit, bool saveImmediately = false);
 
    void SetNeutralMode(valor::NeutralMode mode, bool saveImmediately = false) override;
 
    void SetOpenLoopRamp(units::second_t time, bool saveImmediately = false) override;
 
    void PowerSetter(Output out) override;
 
    void LoggablePeriodic() override;
 
    units::volt_t CalculateAppliedVoltage() override;
 
    using BaseController::SetSimState;
    void SetSimState(units::turn_t pos, units::turns_per_second_t vel, units::turns_per_second_squared_t accel) override;
    void SetSimState(frc::sim::DCMotorSim&) override;
    void SetSimState(frc::sim::FlywheelSim&) override;
 
   private:
    static constexpr units::ampere_t STATOR_CURRENT_LIMIT = 40_A;
 
    valor::PIDF<> pidf;
 
    rev::spark::SparkMaxConfig config;
    std::unique_ptr<rev::spark::SparkMax> followerMotor;
    rev::spark::SparkMaxSim sim;
};
}  // namespace valor