CANSparkBase.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2024 REV Robotics
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of REV Robotics nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#pragma once
 
#ifdef _MSC_VER
// Disable deprecation warnings for this file when using VS compiler
#pragma warning(disable : 4996)
#endif
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
 
#include <stdint.h>
 
#include <atomic>
#include <map>
#include <memory>
#include <string>
 
#include "rev/CANAnalog.h"
#include "rev/CANDigitalInput.h"
#include "rev/CANEncoder.h"
#include "rev/CANPIDController.h"
#include "rev/CANSparkLowLevel.h"
#include "rev/CANSparkMaxDriver.h"
#include "rev/REVLibError.h"
#include "rev/SparkAbsoluteEncoder.h"
#include "rev/SparkAnalogSensor.h"
#include "rev/SparkLimitSwitch.h"
#include "rev/SparkMaxAbsoluteEncoder.h"
#include "rev/SparkMaxAnalogSensor.h"
#include "rev/SparkMaxLimitSwitch.h"
#include "rev/SparkMaxPIDController.h"
#include "rev/SparkMaxRelativeEncoder.h"
#include "rev/SparkPIDController.h"
#include "rev/SparkRelativeEncoder.h"
 
// Defined in HIL tester source
class ConfigBase;
 
namespace rev {
 
class CANSparkBase : public CANSparkLowLevel {
    friend class CANSparkMax;
    friend class CANSparkFlex;
    friend class SparkMaxLimitSwitch;
    friend class SparkMaxRelativeEncoder;
    friend class SparkMaxAlternateEncoder;
    friend class SparkMaxAbsoluteEncoder;
 
    // Defined in HIL tester source
    friend class ::ConfigBase;
 
public:
    enum class IdleMode { kCoast = 0, kBrake = 1 };
 
    enum class WPI_DEPRECATED("You don't need this") InputMode {
        kPWM = 0,
        kCAN = 1
    };
 
    enum class SoftLimitDirection { kForward, kReverse };
 
    enum class FaultID {
        kBrownout = 0,
        kOvercurrent = 1,
        kIWDTReset = 2,
        kMotorFault = 3,
        kSensorFault = 4,
        kStall = 5,
        kEEPROMCRC = 6,
        kCANTX = 7,
        kCANRX = 8,
        kHasReset = 9,
        kDRVFault = 10,
        kOtherFault = 11,
        kSoftLimitFwd = 12,
        kSoftLimitRev = 13,
        kHardLimitFwd = 14,
        kHardLimitRev = 15
    };
 
    struct ExternalFollower {
        int arbId;
        int configId;
    };
 
    static constexpr ExternalFollower kFollowerDisabled{0, 0};
 
    static constexpr ExternalFollower kFollowerSparkMax{0x2051800, 26};
 
    static constexpr ExternalFollower kFollowerSpark{0x2051800, 26};
    static constexpr ExternalFollower kFollowerPhoenix{0x2040080, 27};
 
    ~CANSparkBase() override = default;
 
    /**** Speed Controller Interface ****/
    void Set(double speed) override;
 
    void SetVoltage(units::volt_t output) override;
 
    double Get() const override;
 
    void SetInverted(bool isInverted) override;
 
    bool GetInverted() const override;
 
    void Disable() override;
 
    void StopMotor() override;
 
    virtual SparkRelativeEncoder GetEncoder() = 0;
 
    SparkRelativeEncoder GetEncoder(SparkRelativeEncoder::Type encoderType,
                                    int countsPerRev);
 
    WPI_DEPRECATED(
        "@deprecated Use GetEncoder(SparkRelativeEncoder::Type, int) instead")
    SparkRelativeEncoder GetEncoder(SparkMaxRelativeEncoder::Type encoderType,
                                    int countsPerRev);
 
    WPI_DEPRECATED(
        "Use GetEncoder(SparkMaxRelativeEncoder::Type, int) "
        "instead")
    SparkRelativeEncoder GetEncoder(CANEncoder::EncoderType encoderType,
                                    int countsPerRev);
 
    SparkAnalogSensor GetAnalog(
        SparkAnalogSensor::Mode mode = SparkAnalogSensor::Mode::kAbsolute);
 
    WPI_DEPRECATED("Use GetAnalog(SparkAnalogSensor::Mode) instead")
    SparkAnalogSensor GetAnalog(SparkMaxAnalogSensor::Mode mode);
 
    WPI_DEPRECATED("Use GetAnalog(SparkMaxAnalogSensor::Mode) instead")
    SparkAnalogSensor GetAnalog(CANAnalog::AnalogMode mode);
 
    SparkAbsoluteEncoder GetAbsoluteEncoder(
        SparkAbsoluteEncoder::Type encoderType =
            SparkAbsoluteEncoder::Type::kDutyCycle);
 
    WPI_DEPRECATED("Use GetAbsoluteEncoder(SparkAbsoluteEncoder::Type) instead")
    SparkAbsoluteEncoder GetAbsoluteEncoder(
        SparkMaxAbsoluteEncoder::Type encoderType);
 
    SparkPIDController GetPIDController();
 
    SparkLimitSwitch GetForwardLimitSwitch(SparkLimitSwitch::Type switchType);
 
    WPI_DEPRECATED(
        "@deprecated Use GetForwardLimitSwitch(SparkLimitSwitch::Type) instead")
    SparkLimitSwitch GetForwardLimitSwitch(
        SparkMaxLimitSwitch::Type switchType);
 
    WPI_DEPRECATED(
        "Use "
        "GetForwardLimitSwitch(SparkMaxLimitSwitch::Type) "
        "instead")
    SparkLimitSwitch GetForwardLimitSwitch(
        CANDigitalInput::LimitSwitchPolarity polarity);
 
    SparkLimitSwitch GetReverseLimitSwitch(SparkLimitSwitch::Type switchType);
 
    WPI_DEPRECATED(
        "@deprecated Use GetReverseLimitSwitch(SparkLimitSwitch::Type) instead")
    SparkLimitSwitch GetReverseLimitSwitch(
        SparkMaxLimitSwitch::Type switchType);
 
    WPI_DEPRECATED(
        "Use "
        "GetReverseLimitSwitch(SparkMaxLimitSwitch::Type) "
        "instead")
    SparkLimitSwitch GetReverseLimitSwitch(
        CANDigitalInput::LimitSwitchPolarity polarity);
 
    REVLibError SetSmartCurrentLimit(unsigned int limit);
 
    REVLibError SetSmartCurrentLimit(unsigned int stallLimit,
                                     unsigned int freeLimit,
                                     unsigned int limitRPM = 20000);
 
    REVLibError SetSecondaryCurrentLimit(double limit, int limitCycles = 0);
 
    REVLibError SetIdleMode(IdleMode mode);
 
    IdleMode GetIdleMode();
 
    REVLibError EnableVoltageCompensation(double nominalVoltage);
 
    REVLibError DisableVoltageCompensation();
 
    double GetVoltageCompensationNominalVoltage();
 
    REVLibError SetOpenLoopRampRate(double rate);
 
    REVLibError SetClosedLoopRampRate(double rate);
 
    double GetOpenLoopRampRate();
 
    double GetClosedLoopRampRate();
 
    REVLibError Follow(const CANSparkBase& leader, bool invert = false);
 
    REVLibError Follow(ExternalFollower leader, int deviceID,
                       bool invert = false);
 
    bool IsFollower();
 
    uint16_t GetFaults();
 
    uint16_t GetStickyFaults();
 
    bool GetFault(FaultID faultID) const;
 
    bool GetStickyFault(FaultID faultID) const;
 
    double GetBusVoltage();
 
    double GetAppliedOutput();
 
    double GetOutputCurrent();
 
    double GetMotorTemperature();
 
    REVLibError ClearFaults();
 
    REVLibError BurnFlash();
 
    REVLibError SetCANTimeout(int milliseconds);
 
    REVLibError EnableSoftLimit(SoftLimitDirection direction, bool enable);
 
    bool IsSoftLimitEnabled(SoftLimitDirection direction);
 
    REVLibError SetSoftLimit(SoftLimitDirection direction, double limit);
 
    double GetSoftLimit(SoftLimitDirection direction);
 
    REVLibError GetLastError();
 
protected:
    void attemptToSetDataportConfigOrThrow(c_SparkMax_DataPortConfig config,
                                           std::string errorText);
 
private:
    // Only used for Get() or Set() API
    double m_setpoint{0.0};
 
    std::atomic<bool> m_relativeEncoderCreated{false};
    std::atomic<bool> m_analogSensorCreated{false};
    std::atomic<bool> m_absoluteEncoderCreated{false};
    std::atomic<bool> m_pidControllerCreated{false};
    std::atomic<bool> m_forwardLimitSwitchCreated{false};
    std::atomic<bool> m_reverseLimitSwitchCreated{false};
 
    explicit CANSparkBase(int deviceID, MotorType type, SparkModel model);
 
    int GetFeedbackDeviceID();
 
    // Used by the HIL tester
    SparkRelativeEncoder GetEncoderEvenIfAlreadyCreated(
        SparkRelativeEncoder::Type encoderType =
            SparkRelativeEncoder::Type::kHallSensor,
        int countsPerRev = 42);
 
    uint8_t GetMotorInterface();
 
    REVLibError SetSimFreeSpeed(double freeSpeed);
 
    REVLibError SetSimStallTorque(double stallTorque);
 
    CANSparkBase::SparkModel GetSparkModel();
};
 
}  // namespace rev
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif