SwerveModule.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/swerve/impl/SwerveModuleImpl.hpp"
#include "ctre/phoenix6/CANcoder.hpp"
#include "ctre/phoenix6/TalonFX.hpp"
 
namespace ctre {
namespace phoenix6 {
namespace swerve {
 
/**
 * \brief Swerve Module class that encapsulates a swerve module powered by
 * CTR Electronics devices.
 *
 * This class handles the hardware devices and configures them for
 * swerve module operation using the Phoenix 6 API.
 *
 * This class constructs hardware devices internally, so the user
 * only specifies the constants (IDs, PID gains, gear ratios, etc).
 * Getters for these hardware devices are available.
 */
class SwerveModule {
public:
    /**
     * \brief All possible control requests for the module steer motor.
     */
    using SteerRequestType = impl::SwerveModuleImpl::SteerRequestType;
    /**
     * \brief All possible control requests for the module drive motor.
     */
    using DriveRequestType = impl::SwerveModuleImpl::DriveRequestType;
 
    /**
     * \brief Contains everything the swerve module needs to apply a request.
     */
    using ModuleRequest = impl::SwerveModuleImpl::ModuleRequest;
 
protected:
    /** \brief Number of times to attempt config applies. */
    static constexpr int kNumConfigAttempts = 2;
 
    /** \brief The underlying swerve module instance. */
    impl::SwerveModuleImpl *_module;
 
private:
    hardware::TalonFX _driveMotor;
    hardware::TalonFX _steerMotor;
    hardware::CANcoder _cancoder;
 
public:
    /**
     * \brief Construct a SwerveModule with the specified constants.
     *
     * \param constants  Constants used to construct the module
     * \param canbusName The name of the CAN bus this module is on
     * \param module     The impl#SwerveModuleImpl to use
     */
    SwerveModule(SwerveModuleConstants const &constants, std::string_view canbusName, impl::SwerveModuleImpl &module);
 
    virtual ~SwerveModule() = default;
 
    /**
     * \brief Applies the desired ModuleRequest to this module.
     *
     * \param moduleRequest The request to apply to this module
     */
    virtual void Apply(ModuleRequest const &moduleRequest)
    {
        return _module->Apply(moduleRequest);
    }
 
    /**
     * \brief Controls this module using the specified drive and steer control requests.
     *
     * This is intended only to be used for characterization of the robot; do not use this for normal use.
     *
     * \param driveRequest The control request to apply to the drive motor
     * \param steerRequest The control request to apply to the steer motor
     */
    template <typename DriveReq, typename SteerReq>
    void Apply(DriveReq &&driveRequest, SteerReq &&steerRequest)
    {
        return _module->Apply(std::forward<DriveReq>(driveRequest), std::forward<SteerReq>(steerRequest));
    }
 
    /**
     * \brief Gets the state of this module and passes it back as a
     * SwerveModulePosition object with latency compensated values.
     *
     * This function is blocking when it performs a refresh.
     *
     * \param refresh True if the signals should be refreshed
     * \returns SwerveModulePosition containing this module's state.
     */
    SwerveModulePosition GetPosition(bool refresh)
    {
        return _module->GetPosition(refresh);
    }
 
    /**
     * \brief Gets the last cached swerve module position.
     * This differs from #GetPosition in that it will not
     * perform any latency compensation or refresh the signals.
     *
     * \returns Last cached SwerveModulePosition
     */
    SwerveModulePosition GetCachedPosition() const
    {
        return _module->GetCachedPosition();
    }
 
    /**
     * \brief Get the current state of the module.
     *
     * This is typically used for telemetry, as the SwerveModulePosition
     * is used for odometry.
     *
     * \returns Current state of the module
     */
    SwerveModuleState GetCurrentState() const
    {
        return _module->GetCurrentState();
    }
 
    /**
     * \brief Get the target state of the module.
     *
     * This is typically used for telemetry.
     *
     * \returns Target state of the module
     */
    SwerveModuleState GetTargetState() const
    {
        return _module->GetTargetState();
    }
 
    /**
     * \brief Resets this module's drive motor position to 0 rotations.
     */
    virtual void ResetPosition()
    {
        return _module->ResetPosition();
    }
 
    /**
     * \brief Gets this module's Drive Motor TalonFX reference.
     *
     * This should be used only to access signals and change configurations that the
     * swerve drivetrain does not configure itself.
     *
     * \returns This module's Drive Motor reference
     */
    hardware::TalonFX &GetDriveMotor()
    {
        return _driveMotor;
    }
 
    /**
     * \brief Gets this module's Steer Motor TalonFX reference.
     *
     * This should be used only to access signals and change configurations that the
     * swerve drivetrain does not configure itself.
     *
     * \returns This module's Steer Motor reference
     */
    hardware::TalonFX &GetSteerMotor()
    {
        return _steerMotor;
    }
 
    /**
     * \brief Gets this module's CANcoder reference.
     *
     * This should be used only to access signals and change configurations that the
     * swerve drivetrain does not configure itself.
     *
     * \returns This module's CANcoder reference
     */
    hardware::CANcoder &GetCANcoder()
    {
        return _cancoder;
    }
};
 
}
}
}