SmartMotorControllerConfig.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Yet Another Software Suite
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <any>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include <wpi/commands2/SubsystemBase.hpp>
#include <wpi/math/controller/ArmFeedforward.hpp>
#include <wpi/math/controller/ElevatorFeedforward.hpp>
#include <wpi/math/controller/SimpleMotorFeedforward.hpp>
#include <wpi/math/system/DCMotor.hpp>
#include <wpi/math/trajectory/ExponentialProfile.hpp>
#include <wpi/math/trajectory/TrapezoidProfile.hpp>
#include <wpi/units/acceleration.hpp>
#include <wpi/units/angle.hpp>
#include <wpi/units/angular_acceleration.hpp>
#include <wpi/units/angular_jerk.hpp>
#include <wpi/units/angular_velocity.hpp>
#include <wpi/units/current.hpp>
#include <wpi/units/force.hpp>
#include <wpi/units/length.hpp>
#include <wpi/units/mass.hpp>
#include <wpi/units/moment_of_inertia.hpp>
#include <wpi/units/temperature.hpp>
#include <wpi/units/time.hpp>
#include <wpi/units/velocity.hpp>
#include <wpi/units/voltage.hpp>
 
#include "yams/gearing/MechanismGearing.hpp"
#include "yams/math/LQRConfig.hpp"
 
namespace yams::motorcontrollers {
 
// Forward declaration to avoid circular dependency (SmartMotorController.hpp
// includes this header, so we cannot include it here).
class SmartMotorController;
 
}  // namespace yams::motorcontrollers
 
namespace yams::telemetry {
// Forward declaration; SmartMotorControllerTelemetryConfig.hpp includes this header.
class SmartMotorControllerTelemetryConfig;
}  // namespace yams::telemetry
 
namespace yams::motorcontrollers {
 
using meters_per_second_cubed_t = wpi::units::unit_t<wpi::units::compound_unit<
    wpi::units::meters, wpi::units::inverse<wpi::units::cubed<wpi::units::seconds>>>>;
 
class SmartMotorControllerConfig {
 public:
  enum class ControlMode { CLOSED_LOOP, OPEN_LOOP };
  enum class MotorMode { COAST, BRAKE };
  enum class TelemetryVerbosity { NONE, LOW, MEDIUM, HIGH };
  enum class ClosedLoopControllerSlot { SLOT_0, SLOT_1, SLOT_2, SLOT_3 };
 
  // ---- Feedback -------------------------------------------------------
 
  SmartMotorControllerConfig& WithFeedback(
      double kP, double kI, double kD,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  // ---- Feedforward -------------------------------------------------------
 
  SmartMotorControllerConfig& WithFeedforward(
      const wpi::math::ArmFeedforward& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithFeedforward(
      const wpi::math::ElevatorFeedforward& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithFeedforward(
      const wpi::math::SimpleMotorFeedforward<wpi::units::turns>& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  // ---- Motion profiles ---------------------------------------------------
 
  SmartMotorControllerConfig& WithTrapezoidProfile(
      wpi::units::turns_per_second_t maxVelocity,
      wpi::units::turns_per_second_squared_t maxAcceleration);
 
  SmartMotorControllerConfig& WithLinearTrapezoidProfile(
      wpi::units::meters_per_second_t maxVelocity,
      wpi::units::meters_per_second_squared_t maxAcceleration);
 
  SmartMotorControllerConfig& WithVelocityTrapezoidProfile(
      wpi::units::turns_per_second_squared_t maxAcceleration,
      wpi::units::angular_jerk::turns_per_second_cubed_t maxJerk);
 
  SmartMotorControllerConfig& WithVelocityTrapezoidProfile(
      wpi::units::meters_per_second_squared_t maxAcceleration, meters_per_second_cubed_t maxJerk);
 
  SmartMotorControllerConfig& WithExponentialProfile(double kV, double kA,
                                                     wpi::units::volt_t maxInput);
 
  SmartMotorControllerConfig& WithExponentialProfile(wpi::units::volt_t maxVolts,
                                                     wpi::math::DCMotor motor,
                                                     wpi::units::kilogram_square_meter_t moi);
 
  SmartMotorControllerConfig& WithExponentialProfile(wpi::units::volt_t maxVolts,
                                                     wpi::math::DCMotor motor,
                                                     wpi::units::kilogram_t mass,
                                                     wpi::units::meter_t drumRadius);
 
  SmartMotorControllerConfig& WithExponentialProfile(
      wpi::units::volt_t maxVolts, wpi::units::turns_per_second_t maxVelocity,
      wpi::units::turns_per_second_squared_t maxAcceleration);
 
  SmartMotorControllerConfig& WithExponentialProfile(
      wpi::math::ExponentialProfile<wpi::units::turns, wpi::units::volts>::Constraints constraints);
 
  SmartMotorControllerConfig& WithLinearExponentialProfile(double kV, double kA,
                                                           wpi::units::volt_t maxInput);
 
  // ---- LQR ---------------------------------------------------------------
 
  SmartMotorControllerConfig& WithLQR(
      const math::LQRConfig& lqrConfig,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithLinearClosedLoopController(bool linear);
 
  SmartMotorControllerConfig& WithClosedLoopTolerance(wpi::units::turn_t tolerance);
 
  SmartMotorControllerConfig& WithClosedLoopTolerance(wpi::units::meter_t tolerance);
 
  // ---- Gearing / linear --------------------------------------------------
 
  SmartMotorControllerConfig& WithMotorGearing(const gearing::MechanismGearing& gearing);
 
  SmartMotorControllerConfig& WithMotorGearing(double reductionRatio);
 
  SmartMotorControllerConfig& WithCascadingElevatorStages(int stages);
 
  SmartMotorControllerConfig& WithMechanismCircumference(wpi::units::meter_t circumference);
 
  SmartMotorControllerConfig& WithMechanismCircumference(wpi::units::meter_t gearPitch, int teeth);
 
  SmartMotorControllerConfig& WithMechanismDiameter(wpi::units::meter_t diameter);
 
  SmartMotorControllerConfig& WithMechanismRadius(wpi::units::meter_t radius);
 
  // ---- Limits ------------------------------------------------------------
 
  SmartMotorControllerConfig& WithMechanismLimits(wpi::units::turn_t lower,
                                                  wpi::units::turn_t upper);
 
  SmartMotorControllerConfig& WithMeasurementLimits(wpi::units::meter_t lower,
                                                    wpi::units::meter_t upper);
 
  SmartMotorControllerConfig& WithStatorCurrentLimit(wpi::units::ampere_t limit);
 
  SmartMotorControllerConfig& WithSupplyCurrentLimit(wpi::units::ampere_t limit);
 
  SmartMotorControllerConfig& WithTemperatureCutoff(wpi::units::celsius_t temperature);
 
  SmartMotorControllerConfig& WithClosedLoopMaxVoltage(wpi::units::volt_t maxVoltage);
 
  SmartMotorControllerConfig& WithVoltageCompensation(wpi::units::volt_t voltage);
 
  SmartMotorControllerConfig& WithFeedbackSynchronizationThreshold(wpi::units::turn_t threshold);
 
  // ---- Control behaviour -------------------------------------------------
 
  SmartMotorControllerConfig& WithZeroPower(MotorMode mode);
 
  SmartMotorControllerConfig& WithClosedLoopMode();
 
  SmartMotorControllerConfig& WithOpenLoopMode();
 
  SmartMotorControllerConfig& WithClosedLoopControlPeriod(wpi::units::second_t period);
 
  SmartMotorControllerConfig& WithResetPreviousConfig(bool reset);
 
  // ---- Ramp rates --------------------------------------------------------
 
  SmartMotorControllerConfig& WithOpenLoopRampRate(wpi::units::second_t rampRate);
 
  SmartMotorControllerConfig& WithClosedLoopRampRate(wpi::units::second_t rampRate);
 
  // ---- Inversion ---------------------------------------------------------
 
  SmartMotorControllerConfig& WithMotorInverted(bool inverted);
 
  SmartMotorControllerConfig& WithEncoderInverted(bool inverted);
 
  // ---- External encoder --------------------------------------------------
 
  SmartMotorControllerConfig& WithExternalEncoder(std::any encoder);
 
  SmartMotorControllerConfig& WithUseExternalFeedbackEncoder(bool use);
 
  SmartMotorControllerConfig& WithExternalEncoderInverted(bool inverted);
 
  SmartMotorControllerConfig& WithExternalEncoderConversionFactor(double factor);
 
  SmartMotorControllerConfig& WithExternalEncoderZeroOffset(wpi::units::turn_t zeroOffset);
 
  SmartMotorControllerConfig& WithExternalEncoderZeroOffset(wpi::units::meter_t zeroOffset);
 
  SmartMotorControllerConfig& WithExternalEncoderGearing(const gearing::MechanismGearing& gearing);
 
  SmartMotorControllerConfig& WithExternalEncoderGearing(double reductionRatio);
 
  SmartMotorControllerConfig& WithExternalEncoderDiscontinuityPoint(
      wpi::units::turn_t discontinuityPoint);
 
  SmartMotorControllerConfig& WithContinuousWrapping(wpi::units::turn_t min,
                                                     wpi::units::turn_t max);
 
  // ---- Telemetry ----------------------------------------------------------
 
  SmartMotorControllerConfig& WithTelemetry(
      const std::string& name, TelemetryVerbosity verbosity = TelemetryVerbosity::HIGH);
 
  SmartMotorControllerConfig& WithTelemetry(TelemetryVerbosity verbosity);
 
  SmartMotorControllerConfig& WithTelemetry(
      const std::string& name, telemetry::SmartMotorControllerTelemetryConfig telemetryConfig);
 
  // ---- Subsystem ---------------------------------------------------------
 
  SmartMotorControllerConfig& WithSubsystem(wpi::cmd::SubsystemBase* subsystem);
 
  // ---- Simulation --------------------------------------------------------
 
  SmartMotorControllerConfig& WithSimMotor(wpi::math::DCMotor motor);
 
  SmartMotorControllerConfig& WithSimulationPeriod(wpi::units::second_t period);
 
  // ---- Simulation overrides -----------------------------------------------
 
  SmartMotorControllerConfig& WithSimStartingPosition(wpi::units::degree_t startingAngle);
 
  SmartMotorControllerConfig& WithSimStartingPosition(wpi::units::meter_t startingDistance);
 
  SmartMotorControllerConfig& WithSimFeedforward(
      const wpi::math::ArmFeedforward& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithSimFeedforward(
      const wpi::math::ElevatorFeedforward& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithSimFeedforward(
      const wpi::math::SimpleMotorFeedforward<wpi::units::turns>& ff,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithSimClosedLoopController(
      double kP, double kI, double kD,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithSimClosedLoopController(
      const math::LQRConfig& lqrConfig,
      ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0);
 
  SmartMotorControllerConfig& WithSimTrapezoidProfile(
      wpi::units::turns_per_second_t maxVelocity,
      wpi::units::turns_per_second_squared_t maxAcceleration);
 
  SmartMotorControllerConfig& WithSimTrapezoidProfile(
      wpi::units::meters_per_second_t maxVelocity,
      wpi::units::meters_per_second_squared_t maxAcceleration);
 
  SmartMotorControllerConfig& WithSimExponentialProfile(
      wpi::math::ExponentialProfile<wpi::units::turns, wpi::units::volts>::Constraints constraints);
 
  SmartMotorControllerConfig& WithMOI(wpi::units::kilogram_square_meter_t moi);
 
  SmartMotorControllerConfig& WithMOI(wpi::units::meter_t length, wpi::units::kilogram_t mass);
 
  SmartMotorControllerConfig& WithStartingPosition(wpi::units::degree_t startingAngle);
 
  SmartMotorControllerConfig& WithStartingPosition(wpi::units::meter_t startingDistance);
 
  SmartMotorControllerConfig& WithVendorConfig(std::any cfg);
 
  // ---- Followers -------------------------------------------------------------
 
  SmartMotorControllerConfig& WithFollowers(std::vector<std::pair<std::any, bool>> followers);
 
  SmartMotorControllerConfig& WithLooselyCoupledFollowers(
      std::vector<SmartMotorController*> followers);
 
  void ClearFollowers();
 
  const std::vector<std::pair<std::any, bool>>& GetFollowers() const;
 
  const std::vector<SmartMotorController*>& GetLooselyCoupledFollowers() const;
 
  // ---- Clone -----------------------------------------------------------------
 
  SmartMotorControllerConfig Clone() const;
 
  // ---- Validation ------------------------------------------------------------
 
  void ResetValidationCheck() const;
 
  void ValidateBasicOptions() const;
 
  void ValidateExternalEncoderOptions() const;
 
  SmartMotorControllerConfig& WithVendorControlRequest(std::any req);
 
  // === Getters ============================================================
 
  struct PIDGains {
    double kP{0.0}, kI{0.0}, kD{0.0};
    double kS{0.0}, kV{0.0}, kA{0.0}, kG{0.0};
    std::optional<wpi::math::ArmFeedforward> armFF;
    std::optional<wpi::math::ElevatorFeedforward> elevatorFF;
    std::optional<wpi::math::SimpleMotorFeedforward<wpi::units::turns>> simpleFF;
    std::optional<math::LQRConfig> lqr;
  };
 
  PIDGains GetSlotGains(ClosedLoopControllerSlot slot) const;
 
  std::optional<wpi::math::ArmFeedforward> GetArmFeedforward(ClosedLoopControllerSlot slot) const;
 
  std::optional<wpi::math::ElevatorFeedforward> GetElevatorFeedforward(
      ClosedLoopControllerSlot slot) const;
 
  std::optional<wpi::math::SimpleMotorFeedforward<wpi::units::turns>> GetSimpleFeedforward(
      ClosedLoopControllerSlot slot) const;
 
  std::optional<math::LQRConfig> GetLQR(ClosedLoopControllerSlot slot) const;
 
  double GetKp(ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0) const;
 
  double GetKi(ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0) const;
 
  double GetKd(ClosedLoopControllerSlot slot = ClosedLoopControllerSlot::SLOT_0) const;
 
  bool GetLinearClosedLoopControllerUse() const;
 
  std::optional<wpi::units::turn_t> GetMechanismLowerLimit() const;
  std::optional<wpi::units::turn_t> GetMechanismUpperLimit() const;
  std::optional<wpi::units::meter_t> GetMeasurementLowerLimit() const;
  std::optional<wpi::units::meter_t> GetMeasurementUpperLimit() const;
 
  std::optional<wpi::units::turn_t> GetContinuousWrapping() const;
  std::optional<wpi::units::turn_t> GetContinuousWrappingMin() const;
 
  wpi::units::turn_t GetContinuousWrappingSetpoint(wpi::units::turn_t setpoint,
                                                   wpi::units::turn_t current) const;
 
  std::optional<wpi::units::ampere_t> GetStatorCurrentLimit() const;
  std::optional<int> GetStatorStallCurrentLimit() const;
  std::optional<int> GetSupplyStallCurrentLimit() const;
  std::optional<wpi::units::ampere_t> GetSupplyCurrentLimit() const;
  std::optional<wpi::units::celsius_t> GetTemperatureCutoff() const;
  std::optional<wpi::units::volt_t> GetClosedLoopControllerMaximumVoltage() const;
  std::optional<wpi::units::volt_t> GetVoltageCompensation() const;
  std::optional<wpi::units::turn_t> GetFeedbackSynchronizationThreshold() const;
  std::optional<wpi::units::turn_t> GetClosedLoopTolerance() const;
  bool GetResetPreviousConfig() const;
 
  ControlMode GetMotorControllerMode() const;
  std::optional<MotorMode> GetZeroPower() const;
  std::optional<wpi::units::second_t> GetClosedLoopControlPeriod() const;
  std::optional<wpi::units::second_t> GetOpenLoopRampRate() const;
  std::optional<wpi::units::second_t> GetClosedLoopRampRate() const;
 
  std::optional<bool> GetMotorInverted() const;
  std::optional<bool> GetEncoderInverted() const;
  bool GetVelocityTrapezoidalProfileInUse() const;
 
  std::optional<std::string> GetTelemetryName() const;
  std::optional<TelemetryVerbosity> GetVerbosity() const;
  wpi::cmd::SubsystemBase* GetSubsystem() const;
  bool HasSubsystem() const;
  std::shared_ptr<telemetry::SmartMotorControllerTelemetryConfig>
  GetSmartControllerTelemetryConfig() const;
  std::optional<wpi::math::DCMotor> GetSimMotor() const;
  wpi::units::second_t GetSimulationPeriod() const;
  wpi::units::kilogram_square_meter_t GetMOI() const;
  std::optional<wpi::units::turn_t> GetStartingPosition() const;
  std::optional<std::any> GetVendorConfig() const;
  std::optional<std::any> GetVendorControlRequest() const;
 
  const std::optional<gearing::MechanismGearing>& GetMotorGearing() const;
  std::optional<wpi::units::meter_t> GetMechanismCircumference() const;
 
  std::optional<std::any> GetExternalEncoder() const;
  bool GetUseExternalFeedback() const;
  std::optional<bool> GetExternalEncoderInverted() const;
  std::optional<double> GetExternalEncoderConversionFactor() const;
  std::optional<wpi::units::turn_t> GetExternalEncoderZeroOffset() const;
  const std::optional<gearing::MechanismGearing>& GetExternalEncoderGearing() const;
  std::optional<wpi::units::turn_t> GetExternalEncoderDiscontinuityPoint() const;
 
  bool HasTrapezoidProfile() const;
  bool HasExponentialProfile() const;
  bool HasLinearExponentialProfile() const;
 
  std::optional<wpi::math::TrapezoidProfile<wpi::units::turns>> GetTrapezoidProfile() const;
  std::optional<wpi::math::TrapezoidProfile<wpi::units::meters>> GetLinearTrapezoidProfile() const;
  std::optional<wpi::math::ExponentialProfile<wpi::units::turns, wpi::units::volts>>
  GetExponentialProfile() const;
  std::optional<wpi::math::ExponentialProfile<wpi::units::meters, wpi::units::volts>>
  GetLinearExponentialProfile() const;
 
  std::optional<wpi::units::turns_per_second_t> GetTrapMaxVelocityTurns() const;
  std::optional<wpi::units::turns_per_second_squared_t> GetTrapMaxAccelTurns() const;
  std::optional<wpi::units::meters_per_second_t> GetTrapMaxVelocityLinear() const;
  std::optional<wpi::units::meters_per_second_squared_t> GetTrapMaxAccelLinear() const;
 
  std::optional<double> GetExponentialProfileKV() const;
  std::optional<double> GetExponentialProfileKA() const;
  std::optional<wpi::units::volt_t> GetExponentialProfileMaxInput() const;
 
  wpi::units::meter_t ConvertFromMechanism(wpi::units::turn_t mechanismPosition) const;
 
  wpi::units::meters_per_second_t ConvertFromMechanism(
      wpi::units::turns_per_second_t mechanismVelocity) const;
 
  wpi::units::meters_per_second_squared_t ConvertFromMechanism(
      wpi::units::turns_per_second_squared_t mechanismAcceleration) const;
 
  meters_per_second_cubed_t ConvertFromMechanism(
      wpi::units::angular_jerk::turns_per_second_cubed_t mechanismJerk) const;
 
  wpi::units::turn_t ConvertToMechanism(wpi::units::meter_t distance) const;
 
  wpi::units::turns_per_second_t ConvertToMechanism(wpi::units::meters_per_second_t velocity) const;
 
  wpi::units::turns_per_second_squared_t ConvertToMechanism(
      wpi::units::meters_per_second_squared_t acceleration) const;
 
  wpi::units::angular_jerk::turns_per_second_cubed_t ConvertToMechanism(
      meters_per_second_cubed_t jerk) const;
 
  wpi::units::volt_t ConvertToVoltage(const wpi::math::DCMotor& motor,
                                      wpi::units::newton_t feedforwardForce) const;
 
  wpi::units::ampere_t ConvertToCurrent(const wpi::math::DCMotor& motor,
                                        wpi::units::newton_t feedforwardForce) const;
 
 private:
  static constexpr int kNumSlots = 4;
 
  PIDGains m_slots[kNumSlots];
  // Slots that received PID gains via WithFeedback (zero gains still count as configured).
  bool m_slotHasFeedback[kNumSlots]{false, false, false, false};
  int SlotIndex(ClosedLoopControllerSlot slot) const;
 
  // Validation tracking options that every ApplyConfig implementation must access
  enum class BasicOptions {
    VendorControlRequest,
    ControlMode,
    ClosedLoopMaxVoltage,
    StartingPosition,
    EncoderInverted,
    MotorInverted,
    TemperatureCutoff,
    UpperLimit,
    LowerLimit,
    ZeroPower,
    StatorCurrentLimit,
    SupplyCurrentLimit,
    ClosedLoopRampRate,
    OpenLoopRampRate,
    ExternalEncoder,
    Gearing,
    SlotGains,
    TrapezoidProfile,
    ExponentialProfile,
    ContinuousWrapping,
    Followers,
    LooselyCoupledFollowers,
    VoltageCompensation,
    FeedbackSynchronizationThreshold,
    ClosedLoopTolerance,
    ClosedLoopControlPeriod,
    ResetPreviousConfig,
  };
  enum class ExternalEncoderOptions {
    ZeroOffset,
    DiscontinuityPoint,
    UseExternalFeedback,
    ExternalGearing,
    ExternalEncoderInverted,
  };
  static std::string_view ToString(BasicOptions opt);
  static std::string_view ToString(ExternalEncoderOptions opt);
  mutable std::set<BasicOptions> m_basicOptions;
  mutable std::set<ExternalEncoderOptions> m_externalEncoderOptions;
 
  double ForceToRotorTorque(wpi::units::newton_t feedforwardForce) const;
  void RequireCircumference(const std::string& action) const;
  bool HasClosedLoopController() const;
 
  // Per-slot simulation gain overrides
  struct SimGainsOverride {
    std::optional<double> kP, kI, kD;
    std::optional<math::LQRConfig> lqr;
    std::optional<wpi::math::ArmFeedforward> armFF;
    std::optional<wpi::math::ElevatorFeedforward> elevatorFF;
    std::optional<wpi::math::SimpleMotorFeedforward<wpi::units::turns>> simpleFF;
  };
  SimGainsOverride m_simGains[kNumSlots];
 
  // Profiles
  std::optional<wpi::math::TrapezoidProfile<wpi::units::turns>> m_trapProfile;
  std::optional<wpi::math::TrapezoidProfile<wpi::units::meters>> m_linearTrapProfile;
  std::optional<wpi::math::ExponentialProfile<wpi::units::turns, wpi::units::volts>> m_expoProfile;
  std::optional<wpi::math::ExponentialProfile<wpi::units::meters, wpi::units::volts>>
      m_linearExpoProfile;
  bool m_velocityTrapProfile{false};
  // Stored constraint values for hardware motor controller configuration
  std::optional<wpi::units::turns_per_second_t> m_trapMaxVelTurns;
  std::optional<wpi::units::turns_per_second_squared_t> m_trapMaxAccTurns;
  std::optional<wpi::units::meters_per_second_t> m_trapMaxVelLinear;
  std::optional<wpi::units::meters_per_second_squared_t> m_trapMaxAccLinear;
  // kV/kA in V*s/turn and V*s²/turn for direct CTRE MotionMagicExpo assignment
  std::optional<double> m_expoMotionMagicKV;
  std::optional<double> m_expoMotionMagicKA;
  std::optional<wpi::units::volt_t> m_expoMaxInput;
 
  // Limits
  std::optional<wpi::units::turn_t> m_mechLowerLimit;
  std::optional<wpi::units::turn_t> m_mechUpperLimit;
  std::optional<wpi::units::ampere_t> m_statorCurrentLimit;
  std::optional<wpi::units::ampere_t> m_supplyCurrentLimit;
  std::optional<wpi::units::celsius_t> m_temperatureCutoff;
  std::optional<wpi::units::volt_t> m_closedLoopMaxVoltage;
  std::optional<wpi::units::volt_t> m_voltageCompensation;
  std::optional<wpi::units::turn_t> m_feedbackSynchronizationThreshold;
  std::optional<wpi::units::turn_t> m_closedLoopTolerance;
  bool m_resetPreviousConfig{true};
  std::optional<wpi::units::turn_t> m_continuousWrappingMin;
  std::optional<wpi::units::turn_t> m_continuousWrappingMax;
 
  // Control behaviour
  ControlMode m_controlMode{ControlMode::CLOSED_LOOP};
  std::optional<MotorMode> m_zeroPower;
  std::optional<wpi::units::second_t> m_closedLoopPeriod;
  std::optional<wpi::units::second_t> m_openLoopRampRate;
  std::optional<wpi::units::second_t> m_closedLoopRampRate;
 
  // Inversion empty means the user never called WithMotorInverted / WithEncoderInverted.
  std::optional<bool> m_motorInverted;
  std::optional<bool> m_encoderInverted;
 
  // Gearing / linear
  std::optional<gearing::MechanismGearing> m_motorGearing;
  std::optional<wpi::units::meter_t> m_mechanismCircumference;
  bool m_linearClosedLoopController{false};
 
  // External encoder
  std::optional<std::any> m_externalEncoder;
  bool m_useExternalFeedback{true};
  std::optional<bool> m_externalEncoderInverted;
  std::optional<double> m_externalEncoderConversionFactor;
  std::optional<wpi::units::turn_t> m_externalEncoderZeroOffset;
  std::optional<gearing::MechanismGearing> m_externalEncoderGearing;
  std::optional<wpi::units::turn_t> m_externalEncoderDiscontinuityPoint;
 
  // Telemetry
  std::optional<std::string> m_telemetryName;
  std::optional<TelemetryVerbosity> m_verbosity;
  // shared_ptr so the forward-declared, non-copyable type can be held.
  std::shared_ptr<telemetry::SmartMotorControllerTelemetryConfig> m_telemetryConfig;
 
  wpi::cmd::SubsystemBase* m_subsystem{nullptr};
  std::optional<wpi::math::DCMotor> m_simMotor;
  wpi::units::kilogram_square_meter_t m_moi{0.02_kg_sq_m};
  std::optional<wpi::units::second_t> m_simulationPeriod;
  std::optional<wpi::units::turn_t> m_startingPosition;
  std::optional<wpi::units::meter_t> m_startingPositionDistance;
 
  // Simulation overrides
  std::optional<wpi::units::turn_t> m_simStartingPosition;
  std::optional<wpi::math::TrapezoidProfile<wpi::units::turns>> m_simTrapProfile;
  std::optional<wpi::math::TrapezoidProfile<wpi::units::meters>> m_simLinearTrapProfile;
  std::optional<wpi::math::ExponentialProfile<wpi::units::turns, wpi::units::volts>>
      m_simExpoProfile;
 
  std::optional<std::any> m_vendorConfig;
  std::optional<std::any> m_vendorControlRequest;
 
  // Followers
  std::vector<std::pair<std::any, bool>> m_followers;
  std::vector<SmartMotorController*> m_looseFollowers;
};
 
}  // namespace yams::motorcontrollers