NeoController.h

 
#pragma once
 
#include <memory>
#include <string>
 
#include <rev/SparkMax.h>
#include <rev/config/SparkMaxConfig.h>
#include <rev/sim/SparkMaxSim.h>
 
#include "valkyrie/controllers/BaseController.h"
 
namespace valor {
 
enum NeoControllerType { NEO, NEO_550 };
 
class NeoController : public BaseController, 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 reset() override;
 
    void applyConfig() override;
 
    units::turn_t getPosition() override;
 
    units::ampere_t getCurrent() override;
 
    units::turns_per_second_t getSpeed() override;
 
    void setEncoderPosition(units::turn_t position) override;
 
    units::turn_t getAbsEncoderPosition() override;
 
    void setContinuousWrap(bool wrap, bool saveImmediately = false);
 
    void positionSetter(units::turn_t positon, int slot = 0) override;
    void speedSetter(units::turns_per_second_t speed, 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, units::ampere_t supplyCurrentLimit, units::ampere_t supplyCurrentThreshold,
                          units::second_t supplyTimeThreshold, bool saveImmediately = false);
 
    void setNeutralMode(valor::NeutralMode mode, bool saveImmediately = false);
 
    void setOpenLoopRamp(units::second_t time, bool saveImmediately = false) override;
 
    void powerSetter(units::volt_t voltage) override;
 
    void LoggablePeriodic() override;
 
    units::volt_t calculateAppliedVoltage() override;
 
    void setSimState(frc::sim::DCMotorSim&) override;
 
   private:
    valor::PIDF pidf;
    rev::spark::SparkMaxConfig config;
    std::unique_ptr<rev::spark::SparkMax> followerMotor;
    rev::spark::SparkMaxSim sim;
    double reqPosition;
};
}  // namespace valor