mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-07-01 02:41:48 +00:00
cd5765559a
- CANJaguar also touched up to report it can't do the new control mode (just like with follower). - New third optional param for talon c'tor to speed up enable control frame. - The pulse width routines have been moved to where the script generator puts them. No actual changes there but should help Peter integrate the latest code generator. Last feature additions for TalonSRX HAL for FRC2015-FRC-2016 season. -HAL driver uses control_5 frame if firmware supports it. This allows teams to see/confirm control settings taking effect before enabling the robot. For example selecting the sensor type and going to web-dash to check sensor values now works without having to enable the robot. -Motion profile HAL routines added. Tested on Single-Speed Double reduction (with slave Talon too). -Start moving ctre frame defs into a new common header (better then shoving a bunch of struct defs at top of module). -New child class in CANTalonSRX for buffering motion profile points. Not sure it would be best to leave it as is or make another module. It's trivial now so I thought that was acceptable, (in future it will likely possess compression strategies => no longer trivial). Change-Id: I803680c1a6669ca3f5157d7875942def6f75b540
648 lines
34 KiB
C++
648 lines
34 KiB
C++
/**
|
|
* @brief CAN TALON SRX driver.
|
|
*
|
|
* The TALON SRX is designed to instrument all runtime signals periodically. The default periods are chosen to support 16 TALONs
|
|
* with 10ms update rate for control (throttle or setpoint). However these can be overridden with SetStatusFrameRate. @see SetStatusFrameRate
|
|
* The getters for these unsolicited signals are auto generated at the bottom of this module.
|
|
*
|
|
* Likewise most control signals are sent periodically using the fire-and-forget CAN API.
|
|
* The setters for these unsolicited signals are auto generated at the bottom of this module.
|
|
*
|
|
* Signals that are not available in an unsolicited fashion are the Close Loop gains.
|
|
* For teams that have a single profile for their TALON close loop they can use either the webpage to configure their TALONs once
|
|
* or set the PIDF,Izone,CloseLoopRampRate,etc... once in the robot application. These parameters are saved to flash so once they are
|
|
* loaded in the TALON, they will persist through power cycles and mode changes.
|
|
*
|
|
* For teams that have one or two profiles to switch between, they can use the same strategy since there are two slots to choose from
|
|
* and the ProfileSlotSelect is periodically sent in the 10 ms control frame.
|
|
*
|
|
* For teams that require changing gains frequently, they can use the soliciting API to get and set those parameters. Most likely
|
|
* they will only need to set them in a periodic fashion as a function of what motion the application is attempting.
|
|
* If this API is used, be mindful of the CAN utilization reported in the driver station.
|
|
*
|
|
* Encoder position is measured in encoder edges. Every edge is counted (similar to roboRIO 4X mode).
|
|
* Analog position is 10 bits, meaning 1024 ticks per rotation (0V => 3.3V).
|
|
* Use SetFeedbackDeviceSelect to select which sensor type you need. Once you do that you can use GetSensorPosition()
|
|
* and GetSensorVelocity(). These signals are updated on CANBus every 20ms (by default).
|
|
* If a relative sensor is selected, you can zero (or change the current value) using SetSensorPosition.
|
|
*
|
|
* Analog Input and quadrature position (and velocity) are also explicitly reported in GetEncPosition, GetEncVel, GetAnalogInWithOv, GetAnalogInVel.
|
|
* These signals are available all the time, regardless of what sensor is selected at a rate of 100ms. This allows easy instrumentation
|
|
* for "in the pits" checking of all sensors regardless of modeselect. The 100ms rate is overridable for teams who want to acquire sensor
|
|
* data for processing, not just instrumentation. Or just select the sensor using SetFeedbackDeviceSelect to get it at 20ms.
|
|
*
|
|
* Velocity is in position ticks / 100ms.
|
|
*
|
|
* All output units are in respect to duty cycle (throttle) which is -1023(full reverse) to +1023 (full forward).
|
|
* This includes demand (which specifies duty cycle when in duty cycle mode) and rampRamp, which is in throttle units per 10ms (if nonzero).
|
|
*
|
|
* Pos and velocity close loops are calc'd as
|
|
* err = target - posOrVel.
|
|
* iErr += err;
|
|
* if( (IZone!=0) and abs(err) > IZone)
|
|
* ClearIaccum()
|
|
* output = P X err + I X iErr + D X dErr + F X target
|
|
* dErr = err - lastErr
|
|
* P, I,and D gains are always positive. F can be negative.
|
|
* Motor direction can be reversed using SetRevMotDuringCloseLoopEn if sensor and motor are out of phase.
|
|
* Similarly feedback sensor can also be reversed (multiplied by -1) if you prefer the sensor to be inverted.
|
|
*
|
|
* P gain is specified in throttle per error tick. For example, a value of 102 is ~9.9% (which is 102/1023) throttle per 1
|
|
* ADC unit(10bit) or 1 quadrature encoder edge depending on selected sensor.
|
|
*
|
|
* I gain is specified in throttle per integrated error. For example, a value of 10 equates to ~0.99% (which is 10/1023)
|
|
* for each accumulated ADC unit(10bit) or 1 quadrature encoder edge depending on selected sensor.
|
|
* Close loop and integral accumulator runs every 1ms.
|
|
*
|
|
* D gain is specified in throttle per derivative error. For example a value of 102 equates to ~9.9% (which is 102/1023)
|
|
* per change of 1 unit (ADC or encoder) per ms.
|
|
*
|
|
* I Zone is specified in the same units as sensor position (ADC units or quadrature edges). If pos/vel error is outside of
|
|
* this value, the integrated error will auto-clear...
|
|
* if( (IZone!=0) and abs(err) > IZone)
|
|
* ClearIaccum()
|
|
* ...this is very useful in preventing integral windup and is highly recommended if using full PID to keep stability low.
|
|
*
|
|
* CloseLoopRampRate is in throttle units per 1ms. Set to zero to disable ramping.
|
|
* Works the same as RampThrottle but only is in effect when a close loop mode and profile slot is selected.
|
|
*
|
|
* auto generated using spreadsheet and WpiClassGen.csproj
|
|
* @link https://docs.google.com/spreadsheets/d/1OU_ZV7fZLGYUQ-Uhc8sVAmUmWTlT8XBFYK8lfjg_tac/edit#gid=1766046967
|
|
*/
|
|
#ifndef CanTalonSRX_H_
|
|
#define CanTalonSRX_H_
|
|
#include "ctre/ctre.h" //BIT Defines + Typedefs, TALON_Control_6_MotProfAddTrajPoint_t
|
|
#include "ctre/CtreCanNode.h"
|
|
#include <FRC_NetworkCommunication/CANSessionMux.h> //CAN Comm
|
|
#include <map>
|
|
#include <atomic>
|
|
#include <deque>
|
|
#include <mutex>
|
|
class CanTalonSRX : public CtreCanNode
|
|
{
|
|
private:
|
|
// Use this for determining whether the default move constructor has been
|
|
// called; this prevents us from calling the destructor twice.
|
|
struct HasBeenMoved {
|
|
HasBeenMoved(HasBeenMoved&& other) {
|
|
other.moved = true;
|
|
moved = false;
|
|
}
|
|
HasBeenMoved() = default;
|
|
std::atomic<bool> moved{false};
|
|
operator bool() const { return moved; }
|
|
} m_hasBeenMoved;
|
|
|
|
//---------------------- Vars for opening a CAN stream if caller needs signals that require soliciting */
|
|
uint32_t _can_h; //!< Session handle for catching response params.
|
|
int32_t _can_stat; //!< Session handle status.
|
|
struct tCANStreamMessage _msgBuff[20];
|
|
static int const kMsgCapacity = 20;
|
|
typedef std::map<uint32_t, uint32_t> sigs_t;
|
|
sigs_t _sigs; //!< Catches signal updates that are solicited. Expect this to be very few.
|
|
void OpenSessionIfNeedBe();
|
|
void ProcessStreamMessages();
|
|
/**
|
|
* Called in various places to double check we are using the best control frame.
|
|
* If the Talon firmware is too old, use control 1 framing, which does not allow setting
|
|
* control signals until robot is enabled. If Talon firmware can suport control5, use that
|
|
* since that frame can be transmitted during robot-disable. If calling application
|
|
* uses setParam to set the signal eLegacyControlMode, caller can force using control1
|
|
* if needed for some reason.
|
|
*/
|
|
void UpdateControlId();
|
|
/**
|
|
* @return true if Talon is reporting that it supports control5, and therefore
|
|
* RIO can send control5 to update control params (even when disabled).
|
|
*/
|
|
bool IsControl5Supported();
|
|
/**
|
|
* Get a copy of the control frame to send.
|
|
* @param [out] pointer to eight byte array to fill.
|
|
*/
|
|
void GetControlFrameCopy(uint8_t * toFill);
|
|
/**
|
|
* @return the tx task that transmits Control6 (motion profile control).
|
|
* If it's not scheduled, then schedule it. This is part
|
|
* of making the lazy-framing that only peforms MotionProf framing when needed
|
|
* to save bandwidth.
|
|
*/
|
|
CtreCanNode::txTask<TALON_Control_6_MotProfAddTrajPoint_t> GetControl6();
|
|
/**
|
|
* Caller is either pushing a new motion profile point, or is
|
|
* calling the Process buffer routine. In either case check our
|
|
* flow control to see if we need to start sending control6.
|
|
*/
|
|
void ReactToMotionProfileCall();
|
|
/**
|
|
* Update the NextPt signals inside the control frame given the next pt to send.
|
|
* @param control pointer to the CAN frame payload containing control6. Only the signals that serialize
|
|
* the next trajectory point are updated from the contents of newPt.
|
|
* @param newPt point to the next trajectory that needs to be inserted into Talon RAM.
|
|
*/
|
|
void CopyTrajPtIntoControl(TALON_Control_6_MotProfAddTrajPoint_t * control, const TALON_Control_6_MotProfAddTrajPoint_t * newPt);
|
|
//---------------------- General Control framing ---------------------------//
|
|
/**
|
|
* Frame period for control1 or control5, depending on which one we are using.
|
|
*/
|
|
int _controlPeriodMs = kDefaultControlPeriodMs;
|
|
/**
|
|
* Frame Period of the motion profile control6 frame.
|
|
*/
|
|
int _control6PeriodMs = kDefaultControl6PeriodMs;
|
|
/**
|
|
* When using control5, we still need to send a frame to enable robot. This controls the period.
|
|
* This only is used when we are in the control5 state. @see ControlFrameSelControl5
|
|
*/
|
|
int _enablePeriodMs = kDefaultEnablePeriodMs;
|
|
/**
|
|
* ArbID to use for control frame. Should be either CONTROL_1 or CONTROL_5.
|
|
*/
|
|
uint32_t _controlFrameArbId;
|
|
/**
|
|
* Boolean flag to signal calling applications intent to allow using control5
|
|
* assuming Talon firmware supports it. This can be cleared to force control1 framing.
|
|
*/
|
|
bool _useControl5ifSupported = true;
|
|
//---------------------- Buffering Motion Profile ---------------------------//
|
|
/**
|
|
* Top level Buffer for motion profile trajectory buffering.
|
|
* Basically this buffers up the eight byte CAN frame payloads that are handshaked into
|
|
* the Talon RAM.
|
|
* TODO: Should this be moved into a separate header, and if so where logically should it reside?
|
|
* TODO: Add compression so that multiple CAN frames can be compressed into one exchange.
|
|
*/
|
|
class TrajectoryBuffer {
|
|
public:
|
|
void Clear()
|
|
{
|
|
_motProfTopBuffer.clear();
|
|
}
|
|
/**
|
|
* push caller's uncompressed simple trajectory point.
|
|
*/
|
|
void Push(TALON_Control_6_MotProfAddTrajPoint_huff0_t & pt)
|
|
{
|
|
_motProfTopBuffer.push_back(pt);
|
|
}
|
|
/**
|
|
* Get the next trajectory point CAN frame to send.
|
|
* Underlying layer may compress the next few points together
|
|
* into one control_6 frame.
|
|
*/
|
|
TALON_Control_6_MotProfAddTrajPoint_t * Front()
|
|
{
|
|
/* TODO : peek ahead and use compression strategies */
|
|
_lastFront = _motProfTopBuffer.front();
|
|
return (TALON_Control_6_MotProfAddTrajPoint_t*)&_lastFront;
|
|
}
|
|
void Pop()
|
|
{
|
|
/* TODO : pop multiple points if last front'd point was compressed. */
|
|
_motProfTopBuffer.pop_front();
|
|
}
|
|
unsigned int GetNumTrajectories()
|
|
{
|
|
return _motProfTopBuffer.size();
|
|
}
|
|
bool IsEmpty()
|
|
{
|
|
return _motProfTopBuffer.empty();
|
|
}
|
|
private:
|
|
std::deque<TALON_Control_6_MotProfAddTrajPoint_huff0_t> _motProfTopBuffer;
|
|
TALON_Control_6_MotProfAddTrajPoint_huff0_t _lastFront;
|
|
};
|
|
TrajectoryBuffer _motProfTopBuffer;
|
|
/**
|
|
* To keep buffers from getting out of control, place a cap on the top level buffer. Calling application
|
|
* can stream addition points as they are fed to Talon.
|
|
* Approx memory footprint is this capacity X 8 bytes.
|
|
*/
|
|
static const int kMotionProfileTopBufferCapacity = 2048;
|
|
/**
|
|
* Flow control for streaming trajectories.
|
|
*/
|
|
int32_t _motProfFlowControl = -1;
|
|
/**
|
|
* Since we may need the MP pts to be emptied into Talon in the background
|
|
* make sure the buffering is thread-safe.
|
|
*/
|
|
std::mutex _mutMotProf;
|
|
/**
|
|
* Send a one shot frame to set an arbitrary signal.
|
|
* Most signals are in the control frame so avoid using this API unless you have to.
|
|
* Use this api for...
|
|
* -A motor controller profile signal eProfileParam_XXXs. These are backed up in flash. If you are gain-scheduling then call this periodically.
|
|
* -Default brake and limit switch signals... eOnBoot_XXXs. Avoid doing this, use the override signals in the control frame.
|
|
* Talon will automatically send a PARAM_RESPONSE after the set, so GetParamResponse will catch the latest value after a couple ms.
|
|
*/
|
|
CTR_Code SetParamRaw(uint32_t paramEnum, int32_t rawBits);
|
|
/**
|
|
* Checks cached CAN frames and updating solicited signals.
|
|
*/
|
|
CTR_Code GetParamResponseRaw(uint32_t paramEnum, int32_t & rawBits);
|
|
public:
|
|
static const int kDefaultControlPeriodMs = 10; //!< default control update rate is 10ms.
|
|
static const int kDefaultEnablePeriodMs = 50; //!< default enable update rate is 50ms (when using the new control5 frame).
|
|
static const int kDefaultControl6PeriodMs = 10; //!< Default update rate for motion profile control 6. This only takes effect when calling uses MP functions.
|
|
CanTalonSRX(int deviceNumber = 0,int controlPeriodMs = kDefaultControlPeriodMs,int enablePeriodMs = kDefaultEnablePeriodMs);
|
|
~CanTalonSRX();
|
|
void Set(double value);
|
|
/* mode select enumerations */
|
|
static const int kMode_DutyCycle = 0; //!< Demand is 11bit signed duty cycle [-1023,1023].
|
|
static const int kMode_PositionCloseLoop = 1; //!< Position PIDF.
|
|
static const int kMode_VelocityCloseLoop = 2; //!< Velocity PIDF.
|
|
static const int kMode_CurrentCloseLoop = 3; //!< Current close loop - not done.
|
|
static const int kMode_VoltCompen = 4; //!< Voltage Compensation Mode - not done. Demand is fixed pt target 8.8 volts.
|
|
static const int kMode_SlaveFollower = 5; //!< Demand is the 6 bit Device ID of the 'master' TALON SRX.
|
|
static const int kMode_MotionProfile = 6; //!< Demand is '0' (Disabled), '1' (Enabled), or '2' (Hold).
|
|
static const int kMode_NoDrive = 15; //!< Zero the output (honors brake/coast) regardless of demand. Might be useful if we need to change modes but can't atomically change all the signals we want in between.
|
|
/* limit switch enumerations */
|
|
static const int kLimitSwitchOverride_UseDefaultsFromFlash = 1;
|
|
static const int kLimitSwitchOverride_DisableFwd_DisableRev = 4;
|
|
static const int kLimitSwitchOverride_DisableFwd_EnableRev = 5;
|
|
static const int kLimitSwitchOverride_EnableFwd_DisableRev = 6;
|
|
static const int kLimitSwitchOverride_EnableFwd_EnableRev = 7;
|
|
/* brake override enumerations */
|
|
static const int kBrakeOverride_UseDefaultsFromFlash = 0;
|
|
static const int kBrakeOverride_OverrideCoast = 1;
|
|
static const int kBrakeOverride_OverrideBrake = 2;
|
|
/* feedback device enumerations */
|
|
static const int kFeedbackDev_DigitalQuadEnc=0;
|
|
static const int kFeedbackDev_AnalogPot=2;
|
|
static const int kFeedbackDev_AnalogEncoder=3;
|
|
static const int kFeedbackDev_CountEveryRisingEdge=4;
|
|
static const int kFeedbackDev_CountEveryFallingEdge=5;
|
|
static const int kFeedbackDev_PosIsPulseWidth=8;
|
|
/* ProfileSlotSelect enumerations*/
|
|
static const int kProfileSlotSelect_Slot0 = 0;
|
|
static const int kProfileSlotSelect_Slot1 = 1;
|
|
/* status frame rate types */
|
|
static const int kStatusFrame_General = 0;
|
|
static const int kStatusFrame_Feedback = 1;
|
|
static const int kStatusFrame_Encoder = 2;
|
|
static const int kStatusFrame_AnalogTempVbat = 3;
|
|
static const int kStatusFrame_PulseWidthMeas = 4;
|
|
static const int kStatusFrame_MotionProfile = 5;
|
|
/* Motion Profile status bits */
|
|
static const int kMotionProfileFlag_ActTraj_IsValid = 0x1;
|
|
static const int kMotionProfileFlag_HasUnderrun = 0x2;
|
|
static const int kMotionProfileFlag_IsUnderrun = 0x4;
|
|
static const int kMotionProfileFlag_ActTraj_IsLast = 0x8;
|
|
static const int kMotionProfileFlag_ActTraj_VelOnly = 0x10;
|
|
/* Motion Profile Set Output */
|
|
static const int kMotionProf_Disabled = 0; //!< Motor output is neutral, Motion Profile Executer is not running.
|
|
static const int kMotionProf_Enable = 1; //!< Motor output is updated from Motion Profile Executer, MPE will process the buffered points.
|
|
static const int kMotionProf_Hold = 2; //!< Motor output is updated from Motion Profile Executer, MPE will stay processing current trajectory point.
|
|
/**
|
|
* Signal enumeration for generic signal access.
|
|
* Although every signal is enumerated, only use this for traffic that must be solicited.
|
|
* Use the auto generated getters/setters at bottom of this header as much as possible.
|
|
*/
|
|
typedef enum _param_t{
|
|
eProfileParamSlot0_P=1,
|
|
eProfileParamSlot0_I=2,
|
|
eProfileParamSlot0_D=3,
|
|
eProfileParamSlot0_F=4,
|
|
eProfileParamSlot0_IZone=5,
|
|
eProfileParamSlot0_CloseLoopRampRate=6,
|
|
eProfileParamSlot1_P=11,
|
|
eProfileParamSlot1_I=12,
|
|
eProfileParamSlot1_D=13,
|
|
eProfileParamSlot1_F=14,
|
|
eProfileParamSlot1_IZone=15,
|
|
eProfileParamSlot1_CloseLoopRampRate=16,
|
|
eProfileParamSoftLimitForThreshold=21,
|
|
eProfileParamSoftLimitRevThreshold=22,
|
|
eProfileParamSoftLimitForEnable=23,
|
|
eProfileParamSoftLimitRevEnable=24,
|
|
eOnBoot_BrakeMode=31,
|
|
eOnBoot_LimitSwitch_Forward_NormallyClosed=32,
|
|
eOnBoot_LimitSwitch_Reverse_NormallyClosed=33,
|
|
eOnBoot_LimitSwitch_Forward_Disable=34,
|
|
eOnBoot_LimitSwitch_Reverse_Disable=35,
|
|
eFault_OverTemp=41,
|
|
eFault_UnderVoltage=42,
|
|
eFault_ForLim=43,
|
|
eFault_RevLim=44,
|
|
eFault_HardwareFailure=45,
|
|
eFault_ForSoftLim=46,
|
|
eFault_RevSoftLim=47,
|
|
eStckyFault_OverTemp=48,
|
|
eStckyFault_UnderVoltage=49,
|
|
eStckyFault_ForLim=50,
|
|
eStckyFault_RevLim=51,
|
|
eStckyFault_ForSoftLim=52,
|
|
eStckyFault_RevSoftLim=53,
|
|
eAppliedThrottle=61,
|
|
eCloseLoopErr=62,
|
|
eFeedbackDeviceSelect=63,
|
|
eRevMotDuringCloseLoopEn=64,
|
|
eModeSelect=65,
|
|
eProfileSlotSelect=66,
|
|
eRampThrottle=67,
|
|
eRevFeedbackSensor=68,
|
|
eLimitSwitchEn=69,
|
|
eLimitSwitchClosedFor=70,
|
|
eLimitSwitchClosedRev=71,
|
|
eSensorPosition=73,
|
|
eSensorVelocity=74,
|
|
eCurrent=75,
|
|
eBrakeIsEnabled=76,
|
|
eEncPosition=77,
|
|
eEncVel=78,
|
|
eEncIndexRiseEvents=79,
|
|
eQuadApin=80,
|
|
eQuadBpin=81,
|
|
eQuadIdxpin=82,
|
|
eAnalogInWithOv=83,
|
|
eAnalogInVel=84,
|
|
eTemp=85,
|
|
eBatteryV=86,
|
|
eResetCount=87,
|
|
eResetFlags=88,
|
|
eFirmVers=89,
|
|
eSettingsChanged=90,
|
|
eQuadFilterEn=91,
|
|
ePidIaccum=93,
|
|
eStatus1FrameRate=94, // TALON_Status_1_General_10ms_t
|
|
eStatus2FrameRate=95, // TALON_Status_2_Feedback_20ms_t
|
|
eStatus3FrameRate=96, // TALON_Status_3_Enc_100ms_t
|
|
eStatus4FrameRate=97, // TALON_Status_4_AinTempVbat_100ms_t
|
|
eStatus6FrameRate=98, // TALON_Status_6_Eol_t
|
|
eStatus7FrameRate=99, // TALON_Status_7_Debug_200ms_t
|
|
eClearPositionOnIdx=100,
|
|
//reserved,
|
|
//reserved,
|
|
//reserved,
|
|
ePeakPosOutput=104,
|
|
eNominalPosOutput=105,
|
|
ePeakNegOutput=106,
|
|
eNominalNegOutput=107,
|
|
eQuadIdxPolarity=108,
|
|
eStatus8FrameRate=109, // TALON_Status_8_PulseWid_100ms_t
|
|
eAllowPosOverflow=110,
|
|
eProfileParamSlot0_AllowableClosedLoopErr=111,
|
|
eNumberPotTurns=112,
|
|
eNumberEncoderCPR=113,
|
|
ePwdPosition=114,
|
|
eAinPosition=115,
|
|
eProfileParamVcompRate=116,
|
|
eProfileParamSlot1_AllowableClosedLoopErr=117,
|
|
eStatus9FrameRate=118, // TALON_Status_9_MotProfBuffer_100ms_t
|
|
eMotionProfileHasUnderrunErr = 119,
|
|
eReserved120 = 120,
|
|
eLegacyControlMode = 121,
|
|
}param_t;
|
|
/*---------------------setters and getters that use the solicated param request/response-------------*//**
|
|
* Send a one shot frame to set an arbitrary signal.
|
|
* Most signals are in the control frame so avoid using this API unless you have to.
|
|
* Use this api for...
|
|
* -A motor controller profile signal eProfileParam_XXXs. These are backed up in flash. If you are gain-scheduling then call this periodically.
|
|
* -Default brake and limit switch signals... eOnBoot_XXXs. Avoid doing this, use the override signals in the control frame.
|
|
* Talon will automatically send a PARAM_RESPONSE after the set, so GetParamResponse will catch the latest value after a couple ms.
|
|
*/
|
|
CTR_Code SetParam(param_t paramEnum, double value);
|
|
/**
|
|
* Asks TALON to immedietely respond with signal value. This API is only used for signals that are not sent periodically.
|
|
* This can be useful for reading params that rarely change like Limit Switch settings and PIDF values.
|
|
* @param param to request.
|
|
*/
|
|
CTR_Code RequestParam(param_t paramEnum);
|
|
CTR_Code GetParamResponse(param_t paramEnum, double & value);
|
|
CTR_Code GetParamResponseInt32(param_t paramEnum, int & value);
|
|
/*----- getters and setters that use param request/response. These signals are backed up in flash and will survive a power cycle. ---------*/
|
|
/*----- If your application requires changing these values consider using both slots and switch between slot0 <=> slot1. ------------------*/
|
|
/*----- If your application requires changing these signals frequently then it makes sense to leverage this API. --------------------------*/
|
|
/*----- Getters don't block, so it may require several calls to get the latest value. --------------------------*/
|
|
CTR_Code SetPgain(unsigned slotIdx,double gain);
|
|
CTR_Code SetIgain(unsigned slotIdx,double gain);
|
|
CTR_Code SetDgain(unsigned slotIdx,double gain);
|
|
CTR_Code SetFgain(unsigned slotIdx,double gain);
|
|
CTR_Code SetIzone(unsigned slotIdx,int zone);
|
|
CTR_Code SetCloseLoopRampRate(unsigned slotIdx,int closeLoopRampRate);
|
|
CTR_Code SetVoltageCompensationRate(double voltagePerMs);
|
|
CTR_Code SetSensorPosition(int pos);
|
|
CTR_Code SetForwardSoftLimit(int forwardLimit);
|
|
CTR_Code SetReverseSoftLimit(int reverseLimit);
|
|
CTR_Code SetForwardSoftEnable(int enable);
|
|
CTR_Code SetReverseSoftEnable(int enable);
|
|
CTR_Code GetPgain(unsigned slotIdx,double & gain);
|
|
CTR_Code GetIgain(unsigned slotIdx,double & gain);
|
|
CTR_Code GetDgain(unsigned slotIdx,double & gain);
|
|
CTR_Code GetFgain(unsigned slotIdx,double & gain);
|
|
CTR_Code GetIzone(unsigned slotIdx,int & zone);
|
|
CTR_Code GetCloseLoopRampRate(unsigned slotIdx,int & closeLoopRampRate);
|
|
CTR_Code GetVoltageCompensationRate(double & voltagePerMs);
|
|
CTR_Code GetForwardSoftLimit(int & forwardLimit);
|
|
CTR_Code GetReverseSoftLimit(int & reverseLimit);
|
|
CTR_Code GetForwardSoftEnable(int & enable);
|
|
CTR_Code GetReverseSoftEnable(int & enable);
|
|
/**
|
|
* Change the periodMs of a TALON's status frame. See kStatusFrame_* enums for what's available.
|
|
*/
|
|
CTR_Code SetStatusFrameRate(unsigned frameEnum, unsigned periodMs);
|
|
/**
|
|
* Clear all sticky faults in TALON.
|
|
*/
|
|
CTR_Code ClearStickyFaults();
|
|
/**
|
|
* Calling application can opt to speed up the handshaking between the robot API and the Talon to increase the
|
|
* download rate of the Talon's Motion Profile. Ideally the period should be no more than half the period
|
|
* of a trajectory point.
|
|
*/
|
|
void ChangeMotionControlFramePeriod(uint32_t periodMs);
|
|
/**
|
|
* Clear the buffered motion profile in both Talon RAM (bottom), and in the API (top).
|
|
*/
|
|
void ClearMotionProfileTrajectories();
|
|
/**
|
|
* Retrieve just the buffer count for the api-level (top) buffer.
|
|
* This routine performs no CAN or data structure lookups, so its fast and ideal
|
|
* if caller needs to quickly poll the progress of trajectory points being emptied
|
|
* into Talon's RAM. Otherwise just use GetMotionProfileStatus.
|
|
* @return number of trajectory points in the top buffer.
|
|
*/
|
|
uint32_t GetMotionProfileTopLevelBufferCount();
|
|
/**
|
|
* Retrieve just the buffer full for the api-level (top) buffer.
|
|
* This routine performs no CAN or data structure lookups, so its fast and ideal
|
|
* if caller needs to quickly poll. Otherwise just use GetMotionProfileStatus.
|
|
* @return number of trajectory points in the top buffer.
|
|
*/
|
|
bool IsMotionProfileTopLevelBufferFull();
|
|
/**
|
|
* Push another trajectory point into the top level buffer (which is emptied into
|
|
* the Talon's bottom buffer as room allows).
|
|
* @param targPos servo position in native Talon units (sensor units).
|
|
* @param targVel velocity to feed-forward in native Talon units (sensor units per 100ms).
|
|
* @param profileSlotSelect which slot to pull PIDF gains from. Currently supports 0 or 1.
|
|
* @param timeDurMs time in milliseconds of how long to apply this point.
|
|
* @param velOnly set to nonzero to signal Talon that only the feed-foward velocity should be
|
|
* used, i.e. do not perform PID on position. This is equivalent to setting
|
|
* PID gains to zero, but much more efficient and synchronized to MP.
|
|
* @param isLastPoint set to nonzero to signal Talon to keep processing this trajectory point,
|
|
* instead of jumping to the next one when timeDurMs expires. Otherwise
|
|
* MP executer will eventuall see an empty buffer after the last point expires,
|
|
* causing it to assert the IsUnderRun flag. However this may be desired
|
|
* if calling application nevers wants to terminate the MP.
|
|
* @param zeroPos set to nonzero to signal Talon to "zero" the selected position sensor before executing
|
|
* this trajectory point. Typically the first point should have this set only thus allowing
|
|
* the remainder of the MP positions to be relative to zero.
|
|
* @return CTR_OKAY if trajectory point push ok. CTR_BufferFull if buffer is full due to kMotionProfileTopBufferCapacity.
|
|
*/
|
|
CTR_Code PushMotionProfileTrajectory(int targPos, int targVel, int profileSlotSelect, int timeDurMs, int velOnly, int isLastPoint, int zeroPos);
|
|
/**
|
|
* This must be called periodically to funnel the trajectory points from the API's top level buffer to
|
|
* the Talon's bottom level buffer. Recommendation is to call this twice as fast as the executation rate of the motion profile.
|
|
* So if MP is running with 20ms trajectory points, try calling this routine every 10ms. All motion profile functions are thread-safe
|
|
* through the use of a mutex, so there is no harm in having the caller utilize threading.
|
|
*/
|
|
void ProcessMotionProfileBuffer();
|
|
/**
|
|
* Retrieve all status information.
|
|
* Since this all comes from one CAN frame, its ideal to have one routine to retrieve the frame once and decode everything.
|
|
* @param [out] flags bitfield for status bools. Starting with least significant bit: IsValid, HasUnderrun, IsUnderrun, IsLast, VelOnly.
|
|
*
|
|
* IsValid set when MP executer is processing a trajectory point, and that point's status is instrumented with
|
|
* IsLast, VelOnly, targPos, targVel. However if MP executor is not processing a trajectory point,
|
|
* then this flag is false, and the instrumented signals will be zero.
|
|
* HasUnderrun is set anytime the MP executer is ready to pop another trajectory point from the Talon's RAM, but the buffer
|
|
* is empty. It can only be cleared by using SetParam(eMotionProfileHasUnderrunErr,0);
|
|
* IsUnderrun is set when the MP executer is ready for another point, but the buffer is empty, and cleared when the MP executer
|
|
* does not need another point. HasUnderrun shadows this registor when this register gets set, however HasUnderrun
|
|
* stays asserted until application has process it, and IsUnderrun auto-clears when the condition is resolved.
|
|
* IsLast is set/cleared based on the MP executer's current trajectory point's IsLast value. This assumes
|
|
* IsLast was set when PushMotionProfileTrajectory was used to insert the currently processed trajectory point.
|
|
* VelOnly is set/cleared based on the MP executer's current trajectory point's VelOnly value.
|
|
*
|
|
* @param [out] profileSlotSelect The currently processed trajectory point's selected slot. This can differ in the currently selected slot used for Position and Velocity servo modes.
|
|
* @param [out] targPos The currently processed trajectory point's position in native units. This param is zero if IsValid is zero.
|
|
* @param [out] targVel The currently processed trajectory point's velocity in native units. This param is zero if IsValid is zero.
|
|
* @param [out] topBufferRem The remaining number of points in the top level buffer.
|
|
* @param [out] topBufferCnt The number of points in the top level buffer to be sent to Talon.
|
|
* @param [out] btmBufferCnt The number of points in the bottom level buffer inside Talon.
|
|
* @return CTR error code
|
|
*/
|
|
CTR_Code GetMotionProfileStatus(uint32_t &flags, uint32_t &profileSlotSelect, int32_t &targPos, int32_t &targVel, uint32_t & topBufferRemaining, uint32_t &topBufferCnt, uint32_t &btmBufferCnt, uint32_t &outputEnable);
|
|
/*------------------------ auto generated. This API is optimal since it uses the fire-and-forget CAN interface ----------------------*/
|
|
/*------------------------ These signals should cover the majority of all use cases. ----------------------------------*/
|
|
CTR_Code GetFault_OverTemp(int ¶m);
|
|
CTR_Code GetFault_UnderVoltage(int ¶m);
|
|
CTR_Code GetFault_ForLim(int ¶m);
|
|
CTR_Code GetFault_RevLim(int ¶m);
|
|
CTR_Code GetFault_HardwareFailure(int ¶m);
|
|
CTR_Code GetFault_ForSoftLim(int ¶m);
|
|
CTR_Code GetFault_RevSoftLim(int ¶m);
|
|
CTR_Code GetStckyFault_OverTemp(int ¶m);
|
|
CTR_Code GetStckyFault_UnderVoltage(int ¶m);
|
|
CTR_Code GetStckyFault_ForLim(int ¶m);
|
|
CTR_Code GetStckyFault_RevLim(int ¶m);
|
|
CTR_Code GetStckyFault_ForSoftLim(int ¶m);
|
|
CTR_Code GetStckyFault_RevSoftLim(int ¶m);
|
|
CTR_Code GetAppliedThrottle(int ¶m);
|
|
CTR_Code GetCloseLoopErr(int ¶m);
|
|
CTR_Code GetFeedbackDeviceSelect(int ¶m);
|
|
CTR_Code GetModeSelect(int ¶m);
|
|
CTR_Code GetLimitSwitchEn(int ¶m);
|
|
CTR_Code GetLimitSwitchClosedFor(int ¶m);
|
|
CTR_Code GetLimitSwitchClosedRev(int ¶m);
|
|
CTR_Code GetSensorPosition(int ¶m);
|
|
CTR_Code GetSensorVelocity(int ¶m);
|
|
CTR_Code GetCurrent(double ¶m);
|
|
CTR_Code GetBrakeIsEnabled(int ¶m);
|
|
CTR_Code GetEncPosition(int ¶m);
|
|
CTR_Code GetEncVel(int ¶m);
|
|
CTR_Code GetEncIndexRiseEvents(int ¶m);
|
|
CTR_Code GetQuadApin(int ¶m);
|
|
CTR_Code GetQuadBpin(int ¶m);
|
|
CTR_Code GetQuadIdxpin(int ¶m);
|
|
CTR_Code GetAnalogInWithOv(int ¶m);
|
|
CTR_Code GetAnalogInVel(int ¶m);
|
|
CTR_Code GetTemp(double ¶m);
|
|
CTR_Code GetBatteryV(double ¶m);
|
|
CTR_Code GetResetCount(int ¶m);
|
|
CTR_Code GetResetFlags(int ¶m);
|
|
CTR_Code GetFirmVers(int ¶m);
|
|
CTR_Code GetPulseWidthPosition(int ¶m);
|
|
CTR_Code GetPulseWidthVelocity(int ¶m);
|
|
CTR_Code GetPulseWidthRiseToFallUs(int ¶m);
|
|
CTR_Code GetPulseWidthRiseToRiseUs(int ¶m);
|
|
CTR_Code IsPulseWidthSensorPresent(int ¶m);
|
|
CTR_Code SetDemand(int param);
|
|
CTR_Code SetOverrideLimitSwitchEn(int param);
|
|
CTR_Code SetFeedbackDeviceSelect(int param);
|
|
CTR_Code SetRevMotDuringCloseLoopEn(int param);
|
|
CTR_Code SetOverrideBrakeType(int param);
|
|
CTR_Code SetModeSelect(int param);
|
|
CTR_Code SetModeSelect(int modeSelect,int demand);
|
|
CTR_Code SetProfileSlotSelect(int param);
|
|
CTR_Code SetRampThrottle(int param);
|
|
CTR_Code SetRevFeedbackSensor(int param);
|
|
};
|
|
extern "C" {
|
|
void *c_TalonSRX_Create(int deviceNumber, int controlPeriodMs);
|
|
void c_TalonSRX_Destroy(void *handle);
|
|
CTR_Code c_TalonSRX_SetParam(void *handle, int paramEnum, double value);
|
|
CTR_Code c_TalonSRX_RequestParam(void *handle, int paramEnum);
|
|
CTR_Code c_TalonSRX_GetParamResponse(void *handle, int paramEnum, double *value);
|
|
CTR_Code c_TalonSRX_GetParamResponseInt32(void *handle, int paramEnum, int *value);
|
|
CTR_Code c_TalonSRX_SetStatusFrameRate(void *handle, unsigned frameEnum, unsigned periodMs);
|
|
CTR_Code c_TalonSRX_ClearStickyFaults(void *handle);
|
|
CTR_Code c_TalonSRX_GetFault_OverTemp(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_UnderVoltage(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_ForLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_RevLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_HardwareFailure(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_ForSoftLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFault_RevSoftLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_OverTemp(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_UnderVoltage(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_ForLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_RevLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_ForSoftLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetStckyFault_RevSoftLim(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetAppliedThrottle(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetCloseLoopErr(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFeedbackDeviceSelect(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetModeSelect(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetLimitSwitchEn(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetLimitSwitchClosedFor(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetLimitSwitchClosedRev(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetSensorPosition(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetSensorVelocity(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetCurrent(void *handle, double *param);
|
|
CTR_Code c_TalonSRX_GetBrakeIsEnabled(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetEncPosition(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetEncVel(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetEncIndexRiseEvents(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetQuadApin(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetQuadBpin(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetQuadIdxpin(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetAnalogInWithOv(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetAnalogInVel(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetTemp(void *handle, double *param);
|
|
CTR_Code c_TalonSRX_GetBatteryV(void *handle, double *param);
|
|
CTR_Code c_TalonSRX_GetResetCount(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetResetFlags(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetFirmVers(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetPulseWidthPosition(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetPulseWidthVelocity(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetPulseWidthRiseToFallUs(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_GetPulseWidthRiseToRiseUs(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_IsPulseWidthSensorPresent(void *handle, int *param);
|
|
CTR_Code c_TalonSRX_SetDemand(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetOverrideLimitSwitchEn(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetFeedbackDeviceSelect(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetRevMotDuringCloseLoopEn(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetOverrideBrakeType(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetModeSelect(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetModeSelect2(void *handle, int modeSelect, int demand);
|
|
CTR_Code c_TalonSRX_SetProfileSlotSelect(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetRampThrottle(void *handle, int param);
|
|
CTR_Code c_TalonSRX_SetRevFeedbackSensor(void *handle, int param);
|
|
}
|
|
#endif
|
|
|