From 9050ea7e3d284f4f8c3a7c945b53585e68446bae Mon Sep 17 00:00:00 2001 From: Thomas Clark Date: Sun, 9 Nov 2014 15:51:26 -0500 Subject: [PATCH] Generalize CANJaguar and CANTalon with a CANSpeedController interface in C++ CANSpeedController is a subinterface of SpeedController that adds method prototypes and enums for all of the common smart speed controller features. CANJaguar implements this interfaces. CANTalon does too, but most methods are stubs right now. Change-Id: I67e0177d91e45444657280502a247d787ad5c74c --- wpilibc/wpilibC++Devices/include/CANJaguar.h | 105 ++---- .../include/CANSpeedController.h | 87 +++++ wpilibc/wpilibC++Devices/include/CANTalon.h | 53 ++- wpilibc/wpilibC++Devices/src/CANJaguar.cpp | 34 +- wpilibc/wpilibC++Devices/src/CANTalon.cpp | 350 +++++++++++++++++- .../src/CANTalonTest.cpp | 18 + 6 files changed, 555 insertions(+), 92 deletions(-) create mode 100644 wpilibc/wpilibC++Devices/include/CANSpeedController.h create mode 100644 wpilibc/wpilibC++IntegrationTests/src/CANTalonTest.cpp diff --git a/wpilibc/wpilibC++Devices/include/CANJaguar.h b/wpilibc/wpilibC++Devices/include/CANJaguar.h index 289977d614..4296869d57 100644 --- a/wpilibc/wpilibC++Devices/include/CANJaguar.h +++ b/wpilibc/wpilibC++Devices/include/CANJaguar.h @@ -10,7 +10,7 @@ #include "Resource.h" #include "MotorSafetyHelper.h" #include "PIDOutput.h" -#include "SpeedController.h" +#include "CANSpeedController.h" #include "HAL/Semaphore.hpp" #include "HAL/HAL.hpp" #include "LiveWindow/LiveWindowSendable.h" @@ -23,7 +23,7 @@ * Luminary Micro Jaguar Speed Control */ class CANJaguar : public MotorSafety, - public SpeedController, + public CANSpeedController, public ErrorBase, public LiveWindowSendable, public ITableListener @@ -41,40 +41,11 @@ public: /** Sets a potentiometer as the position reference only.
Passed as the "tag" when setting the control mode. */ static const struct PotentiometerStruct {} Potentiometer; - typedef enum {kPercentVbus, kCurrent, kSpeed, kPosition, kVoltage} ControlMode; - typedef enum {kCurrentFault = 1, kTemperatureFault = 2, kBusVoltageFault = 4, kGateDriverFault = 8} Faults; - typedef enum {kForwardLimit = 1, kReverseLimit = 2} Limits; - typedef enum { - kNeutralMode_Jumper = 0, /** Use the NeutralMode that is set by the jumper wire on the CAN device */ - kNeutralMode_Brake = 1, /** Stop the motor's rotation by applying a force. */ - kNeutralMode_Coast = 2 /** Do not attempt to stop the motor. Instead allow it to coast to a stop without applying resistance. */ - } NeutralMode; - typedef enum { - /** - * Disables the soft position limits and only uses the limit switches to limit rotation. - * @see CANJaguar#GetForwardLimitOK() - * @see CANJaguar#GetReverseLimitOK() - * - */ - kLimitMode_SwitchInputsOnly = 0, - /** - * Enables the soft position limits on the Jaguar. - * These will be used in addition to the limit switches. This does not disable the behavior - * of the limit switch input. - * @see CANJaguar#ConfigSoftPositionLimits(double, double) - */ - kLimitMode_SoftPositionLimits = 1 - } LimitMode; - explicit CANJaguar(uint8_t deviceNumber); virtual ~CANJaguar(); uint8_t getDeviceNumber() const; - - // SpeedController interface - virtual float Get(); - virtual void Set(float value, uint8_t syncGroup=0); - virtual void Disable(); + uint8_t GetHardwareVersion(); // PIDOutput interface virtual void PIDWrite(float output); @@ -104,39 +75,42 @@ public: void SetVoltageMode(QuadEncoderStruct, uint16_t codesPerRev); void SetVoltageMode(PotentiometerStruct); - // Other Accessors - void SetP(double p); - void SetI(double i); - void SetD(double d); - void SetPID(double p, double i, double d); - double GetP(); - double GetI(); - double GetD(); - float GetBusVoltage(); - float GetOutputVoltage(); - float GetOutputCurrent(); - float GetTemperature(); - double GetPosition(); - double GetSpeed(); - bool GetForwardLimitOK(); - bool GetReverseLimitOK(); - uint16_t GetFaults(); - void SetVoltageRampRate(double rampRate); - virtual uint32_t GetFirmwareVersion(); - uint8_t GetHardwareVersion(); - void ConfigNeutralMode(NeutralMode mode); - void ConfigEncoderCodesPerRev(uint16_t codesPerRev); - void ConfigPotentiometerTurns(uint16_t turns); - void ConfigSoftPositionLimits(double forwardLimitPosition, double reverseLimitPosition); - void DisableSoftPositionLimits(); - void ConfigLimitMode(LimitMode mode); - void ConfigForwardLimit(double forwardLimitPosition); - void ConfigReverseLimit(double reverseLimitPosition); - void ConfigMaxOutputVoltage(double voltage); - void ConfigFaultTime(float faultTime); - ControlMode GetControlMode(); + // CANSpeedController interface + virtual float Get() override; + virtual void Set(float value, uint8_t syncGroup=0) override; + virtual void Disable() override; + virtual void SetP(double p) override; + virtual void SetI(double i) override; + virtual void SetD(double d) override; + virtual void SetPID(double p, double i, double d) override; + virtual double GetP() override; + virtual double GetI() override; + virtual double GetD() override; + virtual float GetBusVoltage() override; + virtual float GetOutputVoltage() override; + virtual float GetOutputCurrent() override; + virtual float GetTemperature() override; + virtual double GetPosition() override; + virtual double GetSpeed() override; + virtual bool GetForwardLimitOK() override; + virtual bool GetReverseLimitOK() override; + virtual uint16_t GetFaults() override; + virtual void SetVoltageRampRate(double rampRate) override; + virtual uint32_t GetFirmwareVersion() override; + virtual void ConfigNeutralMode(NeutralMode mode) override; + virtual void ConfigEncoderCodesPerRev(uint16_t codesPerRev) override; + virtual void ConfigPotentiometerTurns(uint16_t turns) override; + virtual void ConfigSoftPositionLimits(double forwardLimitPosition, double reverseLimitPosition) override; + virtual void DisableSoftPositionLimits() override; + virtual void ConfigLimitMode(LimitMode mode) override; + virtual void ConfigForwardLimit(double forwardLimitPosition) override; + virtual void ConfigReverseLimit(double reverseLimitPosition) override; + virtual void ConfigMaxOutputVoltage(double voltage) override; + virtual void ConfigFaultTime(float faultTime) override; + virtual void SetControlMode(ControlMode mode) override; + virtual ControlMode GetControlMode() override; - static void UpdateSyncGroup(uint8_t syncGroup); + static void UpdateSyncGroup(uint8_t syncGroup); void SetExpiration(float timeout); float GetExpiration(); @@ -149,9 +123,6 @@ public: protected: // Control mode helpers - - void ChangeControlMode(ControlMode controlMode); - void SetSpeedReference(uint8_t reference); uint8_t GetSpeedReference(); diff --git a/wpilibc/wpilibC++Devices/include/CANSpeedController.h b/wpilibc/wpilibC++Devices/include/CANSpeedController.h new file mode 100644 index 0000000000..5a94992869 --- /dev/null +++ b/wpilibc/wpilibC++Devices/include/CANSpeedController.h @@ -0,0 +1,87 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) FIRST 2014. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib. */ +/*----------------------------------------------------------------------------*/ +#pragma once + +#include "SpeedController.h" + +/** + * Interface for "smart" CAN-based speed controllers. + * @see CANJaguar + * @see CANTalon + */ +class CANSpeedController : public SpeedController +{ +public: + enum ControlMode { + kPercentVbus, + kCurrent, + kSpeed, + kPosition, + kVoltage + }; + + enum Faults { + kCurrentFault = 1, + kTemperatureFault = 2, + kBusVoltageFault = 4, + kGateDriverFault = 8 + }; + + enum Limits { + kForwardLimit = 1, + kReverseLimit = 2 + }; + + enum NeutralMode { + /** Use the NeutralMode that is set by the jumper wire on the CAN device */ + kNeutralMode_Jumper = 0, + /** Stop the motor's rotation by applying a force. */ + kNeutralMode_Brake = 1, + /** Do not attempt to stop the motor. Instead allow it to coast to a stop without applying resistance. */ + kNeutralMode_Coast = 2 + }; + + enum LimitMode { + /** Only use switches for limits */ + kLimitMode_SwitchInputsOnly = 0, + /** Use both switches and soft limits */ + kLimitMode_SoftPositionLimits = 1 + }; + + virtual float Get() = 0; + virtual void Set(float value, uint8_t syncGroup=0) = 0; + virtual void Disable() = 0; + virtual void SetP(double p) = 0; + virtual void SetI(double i) = 0; + virtual void SetD(double d) = 0; + virtual void SetPID(double p, double i, double d) = 0; + virtual double GetP() = 0; + virtual double GetI() = 0; + virtual double GetD() = 0; + virtual float GetBusVoltage() = 0; + virtual float GetOutputVoltage() = 0; + virtual float GetOutputCurrent() = 0; + virtual float GetTemperature() = 0; + virtual double GetPosition() = 0; + virtual double GetSpeed() = 0; + virtual bool GetForwardLimitOK() = 0; + virtual bool GetReverseLimitOK() = 0; + virtual uint16_t GetFaults() = 0; + virtual void SetVoltageRampRate(double rampRate) = 0; + virtual uint32_t GetFirmwareVersion() = 0; + virtual void ConfigNeutralMode(NeutralMode mode) = 0; + virtual void ConfigEncoderCodesPerRev(uint16_t codesPerRev) = 0; + virtual void ConfigPotentiometerTurns(uint16_t turns) = 0; + virtual void ConfigSoftPositionLimits(double forwardLimitPosition, double reverseLimitPosition) = 0; + virtual void DisableSoftPositionLimits() = 0; + virtual void ConfigLimitMode(LimitMode mode) = 0; + virtual void ConfigForwardLimit(double forwardLimitPosition) = 0; + virtual void ConfigReverseLimit(double reverseLimitPosition) = 0; + virtual void ConfigMaxOutputVoltage(double voltage) = 0; + virtual void ConfigFaultTime(float faultTime) = 0; + virtual void SetControlMode(ControlMode mode) = 0; + virtual ControlMode GetControlMode() = 0; +}; diff --git a/wpilibc/wpilibC++Devices/include/CANTalon.h b/wpilibc/wpilibC++Devices/include/CANTalon.h index 1f17059dcd..2dd1888d3e 100644 --- a/wpilibc/wpilibC++Devices/include/CANTalon.h +++ b/wpilibc/wpilibC++Devices/include/CANTalon.h @@ -6,8 +6,9 @@ #pragma once #include "SafePWM.h" -#include "SpeedController.h" +#include "CANSpeedController.h" #include "PIDOutput.h" +#include "MotorSafetyHelper.h" class CanTalonSRX; @@ -15,16 +16,62 @@ class CanTalonSRX; * CTRE Talon SRX Speed Controller */ class CANTalon : public MotorSafety, - public SpeedController, + public CANSpeedController, public ErrorBase { public: explicit CANTalon(uint8_t deviceNumber); virtual ~CANTalon(); - virtual void Set(float value, uint8_t syncGroup = 0) override; + + // PIDController interface + virtual void PIDWrite(float output) override; + + // MotorSafety interface + virtual void SetExpiration(float timeout) override; + virtual float GetExpiration() override; + virtual bool IsAlive() override; + virtual void StopMotor() override; + virtual void SetSafetyEnabled(bool enabled) override; + virtual bool IsSafetyEnabled() override; + virtual void GetDescription(char *desc) override; + + // CANSpeedController interface virtual float Get() override; + virtual void Set(float value, uint8_t syncGroup=0) override; virtual void Disable() override; + virtual void SetP(double p) override; + virtual void SetI(double i) override; + virtual void SetD(double d) override; + virtual void SetPID(double p, double i, double d) override; + virtual double GetP() override; + virtual double GetI() override; + virtual double GetD() override; + virtual float GetBusVoltage() override; + virtual float GetOutputVoltage() override; + virtual float GetOutputCurrent() override; + virtual float GetTemperature() override; + virtual double GetPosition() override; + virtual double GetSpeed() override; + virtual bool GetForwardLimitOK() override; + virtual bool GetReverseLimitOK() override; + virtual uint16_t GetFaults() override; + virtual void SetVoltageRampRate(double rampRate) override; + virtual uint32_t GetFirmwareVersion() override; + virtual void ConfigNeutralMode(NeutralMode mode) override; + virtual void ConfigEncoderCodesPerRev(uint16_t codesPerRev) override; + virtual void ConfigPotentiometerTurns(uint16_t turns) override; + virtual void ConfigSoftPositionLimits(double forwardLimitPosition, double reverseLimitPosition) override; + virtual void DisableSoftPositionLimits() override; + virtual void ConfigLimitMode(LimitMode mode) override; + virtual void ConfigForwardLimit(double forwardLimitPosition) override; + virtual void ConfigReverseLimit(double reverseLimitPosition) override; + virtual void ConfigMaxOutputVoltage(double voltage) override; + virtual void ConfigFaultTime(float faultTime) override; + virtual void SetControlMode(ControlMode mode) override; + virtual ControlMode GetControlMode() override; private: + uint8_t m_deviceNumber; CanTalonSRX *m_impl; + MotorSafetyHelper *m_safetyHelper; }; diff --git a/wpilibc/wpilibC++Devices/src/CANJaguar.cpp b/wpilibc/wpilibC++Devices/src/CANJaguar.cpp index 86f10d936d..7d07052b5d 100644 --- a/wpilibc/wpilibC++Devices/src/CANJaguar.cpp +++ b/wpilibc/wpilibC++Devices/src/CANJaguar.cpp @@ -1353,7 +1353,7 @@ void CANJaguar::DisableControl() */ void CANJaguar::SetPercentMode() { - ChangeControlMode(kPercentVbus); + SetControlMode(kPercentVbus); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_NONE); } @@ -1368,7 +1368,7 @@ void CANJaguar::SetPercentMode() */ void CANJaguar::SetPercentMode(CANJaguar::EncoderStruct, uint16_t codesPerRev) { - ChangeControlMode(kPercentVbus); + SetControlMode(kPercentVbus); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1384,7 +1384,7 @@ void CANJaguar::SetPercentMode(CANJaguar::EncoderStruct, uint16_t codesPerRev) */ void CANJaguar::SetPercentMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev) { - ChangeControlMode(kPercentVbus); + SetControlMode(kPercentVbus); SetPositionReference(LM_REF_ENCODER); SetSpeedReference(LM_REF_QUAD_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1399,7 +1399,7 @@ void CANJaguar::SetPercentMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRe */ void CANJaguar::SetPercentMode(CANJaguar::PotentiometerStruct) { - ChangeControlMode(kPercentVbus); + SetControlMode(kPercentVbus); SetPositionReference(LM_REF_POT); SetSpeedReference(LM_REF_NONE); ConfigPotentiometerTurns(1); @@ -1415,7 +1415,7 @@ void CANJaguar::SetPercentMode(CANJaguar::PotentiometerStruct) */ void CANJaguar::SetCurrentMode(double p, double i, double d) { - ChangeControlMode(kCurrent); + SetControlMode(kCurrent); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_NONE); SetPID(p, i, d); @@ -1433,7 +1433,7 @@ void CANJaguar::SetCurrentMode(double p, double i, double d) */ void CANJaguar::SetCurrentMode(CANJaguar::EncoderStruct, uint16_t codesPerRev, double p, double i, double d) { - ChangeControlMode(kCurrent); + SetControlMode(kCurrent); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_NONE); ConfigEncoderCodesPerRev(codesPerRev); @@ -1452,7 +1452,7 @@ void CANJaguar::SetCurrentMode(CANJaguar::EncoderStruct, uint16_t codesPerRev, d */ void CANJaguar::SetCurrentMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev, double p, double i, double d) { - ChangeControlMode(kCurrent); + SetControlMode(kCurrent); SetPositionReference(LM_REF_ENCODER); SetSpeedReference(LM_REF_QUAD_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1471,7 +1471,7 @@ void CANJaguar::SetCurrentMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRe */ void CANJaguar::SetCurrentMode(CANJaguar::PotentiometerStruct, double p, double i, double d) { - ChangeControlMode(kCurrent); + SetControlMode(kCurrent); SetPositionReference(LM_REF_POT); SetSpeedReference(LM_REF_NONE); ConfigPotentiometerTurns(1); @@ -1491,7 +1491,7 @@ void CANJaguar::SetCurrentMode(CANJaguar::PotentiometerStruct, double p, double */ void CANJaguar::SetSpeedMode(CANJaguar::EncoderStruct, uint16_t codesPerRev, double p, double i, double d) { - ChangeControlMode(kSpeed); + SetControlMode(kSpeed); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1510,7 +1510,7 @@ void CANJaguar::SetSpeedMode(CANJaguar::EncoderStruct, uint16_t codesPerRev, dou */ void CANJaguar::SetSpeedMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev, double p, double i, double d) { - ChangeControlMode(kSpeed); + SetControlMode(kSpeed); SetPositionReference(LM_REF_ENCODER); SetSpeedReference(LM_REF_QUAD_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1530,7 +1530,7 @@ void CANJaguar::SetSpeedMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev, */ void CANJaguar::SetPositionMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev, double p, double i, double d) { - ChangeControlMode(kPosition); + SetControlMode(kPosition); SetPositionReference(LM_REF_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); SetPID(p, i, d); @@ -1545,7 +1545,7 @@ void CANJaguar::SetPositionMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerR */ void CANJaguar::SetPositionMode(CANJaguar::PotentiometerStruct, double p, double i, double d) { - ChangeControlMode(kPosition); + SetControlMode(kPosition); SetPositionReference(LM_REF_POT); ConfigPotentiometerTurns(1); SetPID(p, i, d); @@ -1557,7 +1557,7 @@ void CANJaguar::SetPositionMode(CANJaguar::PotentiometerStruct, double p, double */ void CANJaguar::SetVoltageMode() { - ChangeControlMode(kVoltage); + SetControlMode(kVoltage); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_NONE); } @@ -1572,7 +1572,7 @@ void CANJaguar::SetVoltageMode() */ void CANJaguar::SetVoltageMode(CANJaguar::EncoderStruct, uint16_t codesPerRev) { - ChangeControlMode(kVoltage); + SetControlMode(kVoltage); SetPositionReference(LM_REF_NONE); SetSpeedReference(LM_REF_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1588,7 +1588,7 @@ void CANJaguar::SetVoltageMode(CANJaguar::EncoderStruct, uint16_t codesPerRev) */ void CANJaguar::SetVoltageMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRev) { - ChangeControlMode(kVoltage); + SetControlMode(kVoltage); SetPositionReference(LM_REF_ENCODER); SetSpeedReference(LM_REF_QUAD_ENCODER); ConfigEncoderCodesPerRev(codesPerRev); @@ -1603,7 +1603,7 @@ void CANJaguar::SetVoltageMode(CANJaguar::QuadEncoderStruct, uint16_t codesPerRe */ void CANJaguar::SetVoltageMode(CANJaguar::PotentiometerStruct) { - ChangeControlMode(kVoltage); + SetControlMode(kVoltage); SetPositionReference(LM_REF_POT); SetSpeedReference(LM_REF_NONE); ConfigPotentiometerTurns(1); @@ -1618,7 +1618,7 @@ void CANJaguar::SetVoltageMode(CANJaguar::PotentiometerStruct) * * @param controlMode The new mode. */ -void CANJaguar::ChangeControlMode(ControlMode controlMode) +void CANJaguar::SetControlMode(ControlMode controlMode) { // Disable the previous mode DisableControl(); diff --git a/wpilibc/wpilibC++Devices/src/CANTalon.cpp b/wpilibc/wpilibC++Devices/src/CANTalon.cpp index e8b5aecfbf..226903d97b 100644 --- a/wpilibc/wpilibC++Devices/src/CANTalon.cpp +++ b/wpilibc/wpilibC++Devices/src/CANTalon.cpp @@ -5,26 +5,366 @@ /*----------------------------------------------------------------------------*/ #include "CANTalon.h" +#include "WPIErrors.h" #include "ctre/CanTalonSRX.h" /** * Constructor for the CANTalon device. * @param deviceNumber The CAN ID of the Talon SRX */ -CANTalon::CANTalon(uint8_t deviceNumber) { - m_impl = new CanTalonSRX(deviceNumber); +CANTalon::CANTalon(uint8_t deviceNumber) + : m_deviceNumber(deviceNumber) + , m_impl(new CanTalonSRX(deviceNumber)) + , m_safetyHelper(new MotorSafetyHelper(this)) +{ } CANTalon::~CANTalon() { delete m_impl; + delete m_safetyHelper; } -void CANTalon::Set(float value, uint8_t syncGroup) { +/** +* Write out the PID value as seen in the PIDOutput base object. +* +* @deprecated Call Set instead. +* +* @param output Write out the PercentVbus value as was computed by the PIDController +*/ +void CANTalon::PIDWrite(float output) +{ + if (GetControlMode() == kPercentVbus) + { + Set(output); + } + else + { + wpi_setWPIErrorWithContext(IncompatibleMode, "PID only supported in PercentVbus mode"); + } } -float CANTalon::Get() { +/** + * TODO documentation (see CANJaguar.cpp) + */ +float CANTalon::Get() +{ + // TODO return 0.0f; } -void CANTalon::Disable() { +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::Set(float value, uint8_t syncGroup) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::Disable() +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetP(double p) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetI(double i) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetD(double d) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetPID(double p, double i, double d) +{ + SetP(p); + SetI(i); + SetD(d); +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +double CANTalon::GetP() +{ + // TODO + return 0.0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +double CANTalon::GetI() +{ + // TODO + return 0.0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +double CANTalon::GetD() +{ + // TODO + return 0.0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +float CANTalon::GetBusVoltage() +{ + // TODO + return 0.0f; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +float CANTalon::GetOutputVoltage() +{ + // TODO + return 0.0f; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +float CANTalon::GetOutputCurrent() +{ + // TODO + return 0.0f; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +float CANTalon::GetTemperature() +{ + // TODO + return 0.0f; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +double CANTalon::GetPosition() +{ + // TODO + return 0.0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +double CANTalon::GetSpeed() +{ + // TODO + return 0.0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +bool CANTalon::GetForwardLimitOK() +{ + // TODO + return false; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +bool CANTalon::GetReverseLimitOK() +{ + // TODO + return false; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +uint16_t CANTalon::GetFaults() +{ + // TODO + return 0; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetVoltageRampRate(double rampRate) +{ + // TODO +} + +/** + * @return The version of the firmware running on the Talon + */ +uint32_t CANTalon::GetFirmwareVersion() +{ + int firmwareVersion; + + CTR_Code status = m_impl->GetFirmVers(firmwareVersion); + if(status != CTR_OKAY) { + wpi_setErrorWithContext(status, getHALErrorMessage(status)); + } + + return firmwareVersion; +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigNeutralMode(NeutralMode mode) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigEncoderCodesPerRev(uint16_t codesPerRev) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigPotentiometerTurns(uint16_t turns) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigSoftPositionLimits(double forwardLimitPosition, double reverseLimitPosition) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::DisableSoftPositionLimits() +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigLimitMode(LimitMode mode) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigForwardLimit(double forwardLimitPosition) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigReverseLimit(double reverseLimitPosition) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigMaxOutputVoltage(double voltage) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::ConfigFaultTime(float faultTime) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +void CANTalon::SetControlMode(CANSpeedController::ControlMode mode) +{ + // TODO +} + +/** + * TODO documentation (see CANJaguar.cpp) + */ +CANSpeedController::ControlMode CANTalon::GetControlMode() +{ + // TODO + return CANSpeedController::ControlMode::kPercentVbus; +} + +void CANTalon::SetExpiration(float timeout) +{ + m_safetyHelper->SetExpiration(timeout); +} + +float CANTalon::GetExpiration() +{ + return m_safetyHelper->GetExpiration(); +} + +bool CANTalon::IsAlive() +{ + return m_safetyHelper->IsAlive(); +} + +bool CANTalon::IsSafetyEnabled() +{ + return m_safetyHelper->IsSafetyEnabled(); +} + +void CANTalon::SetSafetyEnabled(bool enabled) +{ + m_safetyHelper->SetSafetyEnabled(enabled); +} + +void CANTalon::GetDescription(char *desc) +{ + sprintf(desc, "CANTalon ID %d", m_deviceNumber); +} + +/** +* Common interface for stopping the motor +* Part of the MotorSafety interface +*/ +void CANTalon::StopMotor() +{ + // TODO } diff --git a/wpilibc/wpilibC++IntegrationTests/src/CANTalonTest.cpp b/wpilibc/wpilibC++IntegrationTests/src/CANTalonTest.cpp new file mode 100644 index 0000000000..adbf00ebc0 --- /dev/null +++ b/wpilibc/wpilibC++IntegrationTests/src/CANTalonTest.cpp @@ -0,0 +1,18 @@ +/*----------------------------------------------------------------------------*/ +/* Copyright (c) FIRST 2014. All Rights Reserved. */ +/* Open Source Software - may be modified and shared by FRC teams. The code */ +/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib. */ +/*----------------------------------------------------------------------------*/ + +#include "WPILib.h" +#include "gtest/gtest.h" +#include "TestBench.h" + +TEST(CANTalonTest, QuickTest) { + CANTalon talon(10); + + for(;;) { + std::cout << "Firmware version: " << talon.GetFirmwareVersion() << std::endl; + Wait(0.25); + } +}