TalonFX.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Cross The Road Electronics.  All rights reserved.
 * License information can be found in CTRE_LICENSE.txt
 * For support and suggestions contact support@ctr-electronics.com or file
 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
 */
#pragma once
 
#include "ctre/phoenix6/core/CoreTalonFX.hpp"
#include "ctre/phoenix6/wpiutils/MotorSafetyImplem.hpp"
 
#include <wpi/hal/SimDevice.hpp>
#include <wpi/telemetry/TelemetryLoggable.hpp>
 
namespace ctre {
namespace phoenix6 {
namespace hardware {
 
#if defined(_WIN32) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4250)
#endif
 
/**
 * Class description for the Talon FX integrated motor controller.
 */
class TalonFX : public core::CoreTalonFX, public wpi::telemetry::TelemetryLoggable {
public:
    /**
     * \brief The default motor safety timeout IF calling
     * application enables the feature.
     */
    static constexpr auto DEFAULT_SAFETY_EXPIRATION = 100_ms;
 
private:
    std::string m_description;
 
    /* Motor Safety */
    mutable std::unique_ptr<wpiutils::MotorSafetyImplem> m_motorSafety{};
    wpi::units::second_t m_motSafeExpiration{DEFAULT_SAFETY_EXPIRATION};
    mutable std::recursive_mutex m_motorSafetyLock;
 
    /*
     * The StatusSignal getters are copies so that calls
     * to the WPI interface do not update any references
     *
     * These are also mutable so the const getter methods are
     * properly managed.
     */
    mutable StatusSignal<wpi::units::scalar_t> m_dutyCycle = GetDutyCycle(false);
    mutable StatusSignal<wpi::units::turn_t> m_position = GetPosition(false);
    mutable StatusSignal<wpi::units::turns_per_second_t> m_velocity = GetVelocity(false);
 
    controls::DutyCycleOut m_setterControl{0.0};
    controls::NeutralOut m_neutralControl{};
    controls::VoltageOut m_voltageControl{0_V};
 
    wpi::hal::SimDevice m_simMotor;
    wpi::hal::SimDouble m_simSupplyVoltage;
    wpi::hal::SimDouble m_simDutyCycle;
    wpi::hal::SimDouble m_simMotorVoltage;
    wpi::hal::SimDouble m_simTorqueCurrent;
    wpi::hal::SimDouble m_simSupplyCurrent;
 
    wpi::hal::SimDevice m_simForwardLimit;
    wpi::hal::SimBoolean m_simForwardLimitValue;
 
    wpi::hal::SimDevice m_simReverseLimit;
    wpi::hal::SimBoolean m_simReverseLimitValue;
 
    wpi::hal::SimDevice m_simRotor;
    wpi::hal::SimDouble m_simRotorPos;
    wpi::hal::SimDouble m_simRotorRawPos;
    wpi::hal::SimDouble m_simRotorVel;
    wpi::hal::SimDouble m_simRotorAccel;
 
    int32_t m_simPeriodicUid{-1};
    std::vector<int32_t> m_simValueChangedUids;
 
    static void OnValueChanged(
        const char* name, void *param, HAL_SimValueHandle handle,
        HAL_Bool readonly, const struct HAL_Value* value
    );
    static void OnPeriodic(void* param);
 
    /** caller must lock appropriately */
    wpiutils::MotorSafetyImplem &GetMotorSafety() const;
 
public:
    /**
     * Constructs a new Talon FX motor controller object.
     *
     * \param deviceId    ID of the device, as configured in Phoenix Tuner
     * \param canbus      The CAN bus this device is on
     */
    TalonFX(int deviceId, CANBus canbus);
 
    ~TalonFX();
 
    /**
     * \brief Constructs a stubbed-out TalonFX, where all status signals, controls,
     * configs, etc. perform no action and immediately return OK. This can be used to
     * silence error messages for devices that have been completely removed from the robot.
     *
     * \returns Stubbed-out TalonFX
     */
    static TalonFX None()
    {
        return TalonFX{-1, CANBus{}};
    }
 
    /**
     * \brief Sets the throttle of the motor controller.
     *
     * \param throttle The throttle where -1 indicates full reverse and 1
     *     indicates full forward.
     */
    void SetThrottle(double throttle)
    {
        SetControl(m_setterControl.WithOutput(throttle));
    }
    /**
     * \brief Sets the direct voltage output of the motor controller.
     *
     * Compensates for the current bus voltage to ensure that the desired voltage
     * is output even if the battery voltage is below 12V - highly useful when the
     * voltage outputs are "meaningful" (e.g. they come from a feedforward
     * calculation).
     *
     * \param voltage The voltage.
     */
    void SetVoltage(wpi::units::volt_t voltage)
    {
        SetControl(m_voltageControl.WithOutput(voltage));
    }
    /**
     * \brief Gets the throttle of the motor controller.
     *
     * \returns The throttle where -1 represents full reverse and 1 represents full
     *     forward.
     */
    double GetThrottle() const
    {
        return m_dutyCycle.Refresh().GetValue();
    }
    /**
     * \brief Disables the motor controller.
     */
    void Disable()
    {
        SetControl(m_neutralControl);
    }
 
    /**
     * \brief Sets the mode of operation when output is neutral or disabled.
     * This is equivalent to setting the configs#MotorOutputConfigs#NeutralMode
     * when applying a configs#TalonFXConfiguration to the motor.
     *
     * Since neutral mode is a config, this API is blocking. We recommend
     * that users avoid calling this API periodically.
     *
     * \param neutralMode The state of the motor controller bridge when output is neutral or disabled
     * \param timeoutSeconds Maximum amount of time to wait when performing configuration
     * \returns Status of refreshing and applying the neutral mode config
     */
    ctre::phoenix::StatusCode ConfigNeutralMode(signals::NeutralModeValue neutralMode, wpi::units::second_t timeoutSeconds = 100_ms);
 
    /* ----- Motor Safety ----- */
    /**
     * \brief Feed the motor safety object.
     *
     * Resets the timer on this object that is used to do the timeouts.
     */
    void Feed();
    /**
     * \brief Set the expiration time for the corresponding motor safety object.
     *
     * \param expirationTime The timeout value.
     */
    void SetExpiration(wpi::units::second_t expirationTime);
    /**
     * \brief Retrieve the timeout value for the corresponding motor safety object.
     *
     * \returns the timeout value.
     */
    wpi::units::second_t GetExpiration() const;
    /**
     * \brief Determine of the motor is still operating or has timed out.
     *
     * \returns true if the motor is still operating normally and hasn't timed out.
     */
    bool IsAlive() const;
    /**
     * \brief Enable/disable motor safety for this device.
     *
     * Turn on and off the motor safety option for this object.
     *
     * \param enabled True if motor safety is enforced for this object.
     */
    void SetSafetyEnabled(bool enabled);
    /**
     * \brief Return the state of the motor safety enabled flag.
     *
     * Return if the motor safety is currently enabled for this device.
     *
     * \returns True if motor safety is enforced for this device
     */
    bool IsSafetyEnabled() const;
    /**
     * \brief Called to stop the motor when the timeout expires.
     */
    void StopMotor() { Disable(); }
    /**
     * \returns Description of the motor controller
     */
    virtual std::string GetDescription() const { return m_description; }
 
    /**
     * \brief Logs the object to a wpi::telemetry::TelemetryTable.
     *
     * \param table Telemetry table
     */
    void LogTo(wpi::telemetry::TelemetryTable &table) const override;
 
    /**
     * \brief Gets the telemetry table type.
     *
     * \returns Table type
     */
    std::string_view GetTelemetryType() const override { return "Motor Controller"; }
 
protected:
    //------------- Intercept CTRE calls for motor safety ------------//
    ctre::phoenix::StatusCode SetControlPrivate(controls::ControlRequest const &request) override
    {
        Feed();
        return CoreTalonFX::SetControlPrivate(request);
    }
};
 
#if defined(_WIN32) || defined(_WIN64)
#pragma warning(pop)
#endif
 
}
}
}