WheelForceCalculator.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/utility/Kinematics.hpp"
#include <wpi/units/force.hpp>
#include <wpi/units/moment_of_inertia.hpp>
#include <wpi/units/torque.hpp>
#include <vector>
 
namespace ctre {
namespace phoenix6 {
namespace swerve {
 
/**
 * Calculates wheel force feedforwards for a SwerveDrivetrain.
 * Wheel force feedforwards can be used to improve accuracy of path
 * following in regions of acceleration.
 *
 * Many path planning libraries (such as PathPlanner and Choreo) already
 * provide per-module force feedforwards, which should be preferred over
 * this class.
 */
class WheelForceCalculator {
public:
    /** \brief Wheel force feedforwards to apply to a swerve drivetrain. */
    struct Feedforwards {
        /** \brief The X component of the forces in Newtons. */
        std::vector<wpi::units::newton_t> x;
        /** \brief The Y component of the forces in Newtons. */
        std::vector<wpi::units::newton_t> y;
 
        /**
         * \brief Constructs a new set of wheel force feedforwards.
         *
         * \param numModules The number of swerve modules
         */
        Feedforwards(size_t numModules) :
            x(numModules),
            y(numModules)
        {}
    };
 
private:
    std::vector<Translation2d> moduleLocations;
    wpi::units::kilogram_t mass;
    wpi::units::kilogram_square_meter_t moi;
 
public:
    /**
     * \brief Constructs a new wheel force feedforward calculator for the given
     * drivetrain characteristics.
     *
     * \param moduleLocations The drivetrain swerve module locations
     * \param mass The mass of the robot
     * \param moi The moment of inertia of the robot
     */
    WheelForceCalculator(
        std::vector<Translation2d> moduleLocations,
        wpi::units::kilogram_t mass,
        wpi::units::kilogram_square_meter_t moi
    ) :
        moduleLocations{std::move(moduleLocations)},
        mass{mass},
        moi{moi}
    {}
 
    /**
     * \brief Calculates wheel force feedforwards for the desired robot acceleration.
     * This can be used with either robot-centric or field-centric accelerations;
     * the returned force feedforwards will match in being robot-/field-centric.
     *
     * \param acceleration Acceleration of the robot
     * \param centerOfRotation Center of rotation
     * \returns Wheel force feedforwards to apply
     */
    Feedforwards Calculate(
        ChassisAccelerations const &acceleration,
        Translation2d const &centerOfRotation = {}
    ) const {
        wpi::units::newton_t const fx = acceleration.ax * mass;
        wpi::units::newton_t const fy = acceleration.ay * mass;
        wpi::units::newton_meter_t const tau = acceleration.alpha * moi / 1_rad;
 
        Feedforwards feedforwards{moduleLocations.size()};
        for (size_t i = 0; i < moduleLocations.size(); ++i) {
            Translation2d const r = moduleLocations[i] - centerOfRotation;
 
            Translation2d const f_tau{tau / r.Norm() * 1_m/1_N, r.Angle() + Rotation2d{90_deg}};
            feedforwards.x[i] = (fx + f_tau.X() * 1_N/1_m) / moduleLocations.size();
            feedforwards.y[i] = (fy + f_tau.Y() * 1_N/1_m) / moduleLocations.size();
        }
 
        return feedforwards;
    }
 
    /**
     * \brief Calculates wheel force feedforwards for the desired change in velocity.
     * This can be used with either robot-centric or field-centric velocities; the
     * returned force feedforwards will match in being robot-/field-centric.
     *
     * \param dt The change in time between the path setpoints
     * \param prev The previous ChassisVelocities setpoint of the path
     * \param current The new ChassisVelocities setpoint of the path
     * \param centerOfRotation Center of rotation
     * \returns Wheel force feedforwards to apply
     */
    Feedforwards Calculate(
        wpi::units::second_t dt,
        ChassisVelocities const &prev,
        ChassisVelocities const &current,
        Translation2d const &centerOfRotation = {}
    ) const {
        ChassisAccelerations const accelerations{
            (current.vx - prev.vx) / dt,
            (current.vy - prev.vy) / dt,
            (current.omega - prev.omega) / dt
        };
        return Calculate(accelerations, centerOfRotation);
    }
};
 
}
}
}