CTRE Phoenix 6 C++ 26.3.0
Loading...
Searching...
No Matches
CoreTalonFX.hpp
Go to the documentation of this file.
1/*
2 * Copyright (C) Cross The Road Electronics.  All rights reserved.
3 * License information can be found in CTRE_LICENSE.txt
4 * For support and suggestions contact support@ctr-electronics.com or file
5 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
6 */
7#pragma once
8
9#include "ctre/phoenix6/hardware/ParentDevice.hpp"
10#include "ctre/phoenix6/configs/Configuration.hpp"
11#include "ctre/phoenix6/configs/Configurator.hpp"
12#include "ctre/phoenix6/signals/SpnEnums.hpp"
13#include "ctre/phoenix6/hardware/traits/CommonTalonWithFOC.hpp"
14#include "ctre/phoenix6/configs/MotorOutputConfigs.hpp"
15#include "ctre/phoenix6/configs/CurrentLimitsConfigs.hpp"
16#include "ctre/phoenix6/configs/VoltageConfigs.hpp"
17#include "ctre/phoenix6/configs/TorqueCurrentConfigs.hpp"
18#include "ctre/phoenix6/configs/FeedbackConfigs.hpp"
19#include "ctre/phoenix6/configs/DifferentialSensorsConfigs.hpp"
20#include "ctre/phoenix6/configs/DifferentialConstantsConfigs.hpp"
21#include "ctre/phoenix6/configs/OpenLoopRampsConfigs.hpp"
22#include "ctre/phoenix6/configs/ClosedLoopRampsConfigs.hpp"
23#include "ctre/phoenix6/configs/HardwareLimitSwitchConfigs.hpp"
24#include "ctre/phoenix6/configs/AudioConfigs.hpp"
25#include "ctre/phoenix6/configs/SoftwareLimitSwitchConfigs.hpp"
26#include "ctre/phoenix6/configs/MotionMagicConfigs.hpp"
27#include "ctre/phoenix6/configs/CustomParamsConfigs.hpp"
28#include "ctre/phoenix6/configs/ClosedLoopGeneralConfigs.hpp"
29#include "ctre/phoenix6/configs/Slot0Configs.hpp"
30#include "ctre/phoenix6/configs/Slot1Configs.hpp"
31#include "ctre/phoenix6/configs/Slot2Configs.hpp"
32#include "ctre/phoenix6/configs/SlotConfigs.hpp"
33#include "ctre/phoenix6/controls/DutyCycleOut.hpp"
34#include "ctre/phoenix6/controls/TorqueCurrentFOC.hpp"
35#include "ctre/phoenix6/controls/VoltageOut.hpp"
36#include "ctre/phoenix6/controls/PositionDutyCycle.hpp"
37#include "ctre/phoenix6/controls/PositionVoltage.hpp"
38#include "ctre/phoenix6/controls/PositionTorqueCurrentFOC.hpp"
39#include "ctre/phoenix6/controls/VelocityDutyCycle.hpp"
40#include "ctre/phoenix6/controls/VelocityVoltage.hpp"
41#include "ctre/phoenix6/controls/VelocityTorqueCurrentFOC.hpp"
42#include "ctre/phoenix6/controls/MotionMagicDutyCycle.hpp"
43#include "ctre/phoenix6/controls/MotionMagicVoltage.hpp"
44#include "ctre/phoenix6/controls/MotionMagicTorqueCurrentFOC.hpp"
45#include "ctre/phoenix6/controls/DifferentialDutyCycle.hpp"
46#include "ctre/phoenix6/controls/DifferentialVoltage.hpp"
47#include "ctre/phoenix6/controls/DifferentialPositionDutyCycle.hpp"
48#include "ctre/phoenix6/controls/DifferentialPositionVoltage.hpp"
49#include "ctre/phoenix6/controls/DifferentialVelocityDutyCycle.hpp"
50#include "ctre/phoenix6/controls/DifferentialVelocityVoltage.hpp"
51#include "ctre/phoenix6/controls/DifferentialMotionMagicDutyCycle.hpp"
52#include "ctre/phoenix6/controls/DifferentialMotionMagicVoltage.hpp"
53#include "ctre/phoenix6/controls/DifferentialMotionMagicExpoDutyCycle.hpp"
54#include "ctre/phoenix6/controls/DifferentialMotionMagicExpoVoltage.hpp"
55#include "ctre/phoenix6/controls/DifferentialMotionMagicVelocityDutyCycle.hpp"
56#include "ctre/phoenix6/controls/DifferentialMotionMagicVelocityVoltage.hpp"
57#include "ctre/phoenix6/controls/Follower.hpp"
58#include "ctre/phoenix6/controls/StrictFollower.hpp"
59#include "ctre/phoenix6/controls/DifferentialFollower.hpp"
60#include "ctre/phoenix6/controls/DifferentialStrictFollower.hpp"
61#include "ctre/phoenix6/controls/NeutralOut.hpp"
62#include "ctre/phoenix6/controls/CoastOut.hpp"
63#include "ctre/phoenix6/controls/StaticBrake.hpp"
64#include "ctre/phoenix6/controls/MusicTone.hpp"
65#include "ctre/phoenix6/controls/MotionMagicVelocityDutyCycle.hpp"
66#include "ctre/phoenix6/controls/MotionMagicVelocityTorqueCurrentFOC.hpp"
67#include "ctre/phoenix6/controls/MotionMagicVelocityVoltage.hpp"
68#include "ctre/phoenix6/controls/MotionMagicExpoDutyCycle.hpp"
69#include "ctre/phoenix6/controls/MotionMagicExpoVoltage.hpp"
70#include "ctre/phoenix6/controls/MotionMagicExpoTorqueCurrentFOC.hpp"
71#include "ctre/phoenix6/controls/DynamicMotionMagicDutyCycle.hpp"
72#include "ctre/phoenix6/controls/DynamicMotionMagicVoltage.hpp"
73#include "ctre/phoenix6/controls/DynamicMotionMagicTorqueCurrentFOC.hpp"
74#include "ctre/phoenix6/controls/DynamicMotionMagicExpoDutyCycle.hpp"
75#include "ctre/phoenix6/controls/DynamicMotionMagicExpoVoltage.hpp"
76#include "ctre/phoenix6/controls/DynamicMotionMagicExpoTorqueCurrentFOC.hpp"
77#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Position.hpp"
78#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Position.hpp"
79#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Position.hpp"
80#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Position.hpp"
81#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Position.hpp"
82#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Position.hpp"
83#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Velocity.hpp"
84#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Velocity.hpp"
85#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Velocity.hpp"
86#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Velocity.hpp"
87#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Velocity.hpp"
88#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Velocity.hpp"
89#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Open.hpp"
90#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Open.hpp"
91#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Open.hpp"
92#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Open.hpp"
93#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Open.hpp"
94#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Open.hpp"
95#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Position.hpp"
96#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Position.hpp"
97#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Position.hpp"
98#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Position.hpp"
99#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Position.hpp"
100#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Position.hpp"
101#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Velocity.hpp"
102#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Velocity.hpp"
103#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Velocity.hpp"
104#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Velocity.hpp"
105#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Velocity.hpp"
106#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Velocity.hpp"
107#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Open.hpp"
108#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Open.hpp"
109#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Open.hpp"
110#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Open.hpp"
111#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Open.hpp"
112#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Open.hpp"
113#include "ctre/phoenix6/controls/compound/Diff_TorqueCurrentFOC_Position.hpp"
114#include "ctre/phoenix6/controls/compound/Diff_PositionTorqueCurrentFOC_Position.hpp"
115#include "ctre/phoenix6/controls/compound/Diff_VelocityTorqueCurrentFOC_Position.hpp"
116#include "ctre/phoenix6/controls/compound/Diff_MotionMagicTorqueCurrentFOC_Position.hpp"
117#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoTorqueCurrentFOC_Position.hpp"
118#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityTorqueCurrentFOC_Position.hpp"
119#include "ctre/phoenix6/controls/compound/Diff_TorqueCurrentFOC_Velocity.hpp"
120#include "ctre/phoenix6/controls/compound/Diff_PositionTorqueCurrentFOC_Velocity.hpp"
121#include "ctre/phoenix6/controls/compound/Diff_VelocityTorqueCurrentFOC_Velocity.hpp"
122#include "ctre/phoenix6/controls/compound/Diff_MotionMagicTorqueCurrentFOC_Velocity.hpp"
123#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoTorqueCurrentFOC_Velocity.hpp"
124#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity.hpp"
125#include "ctre/phoenix6/controls/compound/Diff_TorqueCurrentFOC_Open.hpp"
126#include "ctre/phoenix6/controls/compound/Diff_PositionTorqueCurrentFOC_Open.hpp"
127#include "ctre/phoenix6/controls/compound/Diff_VelocityTorqueCurrentFOC_Open.hpp"
128#include "ctre/phoenix6/controls/compound/Diff_MotionMagicTorqueCurrentFOC_Open.hpp"
129#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoTorqueCurrentFOC_Open.hpp"
130#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityTorqueCurrentFOC_Open.hpp"
131#include "ctre/phoenix6/sim/TalonFXSimState.hpp"
132#include "ctre/unit/motor_constants.h"
133#include <units/angle.h>
134#include <units/angular_acceleration.h>
135#include <units/angular_velocity.h>
136#include <units/current.h>
137#include <units/dimensionless.h>
138#include <units/temperature.h>
139#include <units/voltage.h>
140
141namespace ctre {
142namespace phoenix6 {
143
144namespace hardware {
145namespace core {
146 class CoreTalonFX;
147}
148}
149
150namespace configs {
151
152/**
153 * Class description for the Talon FX integrated motor controller.
154 *
155 * This defines all configurations for the hardware#TalonFX.
156 */
157class TalonFXConfiguration : public ParentConfiguration
158{
159public:
160 constexpr TalonFXConfiguration() = default;
161
162 /**
163 * \brief True if we should factory default newer unsupported configs,
164 * false to leave newer unsupported configs alone.
165 *
166 * \details This flag addresses a corner case where the device may have
167 * firmware with newer configs that didn't exist when this
168 * version of the API was built. If this occurs and this
169 * flag is true, unsupported new configs will be factory
170 * defaulted to avoid unexpected behavior.
171 *
172 * This is also the behavior in Phoenix 5, so this flag
173 * is defaulted to true to match.
174 */
175 bool FutureProofConfigs{true};
176
177
178 /**
179 * \brief Configs that directly affect motor output.
180 *
181 * \details Includes motor invert, neutral mode, and other features
182 * related to motor output.
183 *
184 * Parameter list:
185 *
186 * - MotorOutputConfigs#Inverted
187 * - MotorOutputConfigs#NeutralMode
188 * - MotorOutputConfigs#DutyCycleNeutralDeadband
189 * - MotorOutputConfigs#PeakForwardDutyCycle
190 * - MotorOutputConfigs#PeakReverseDutyCycle
191 * - MotorOutputConfigs#ControlTimesyncFreqHz
192 *
193 */
194 MotorOutputConfigs MotorOutput;
195
196 /**
197 * \brief Configs that directly affect current limiting features.
198 *
199 * \details Contains the supply/stator current limit thresholds and
200 * whether to enable them.
201 *
202 * Parameter list:
203 *
204 * - CurrentLimitsConfigs#StatorCurrentLimit
205 * - CurrentLimitsConfigs#StatorCurrentLimitEnable
206 * - CurrentLimitsConfigs#SupplyCurrentLimit
207 * - CurrentLimitsConfigs#SupplyCurrentLimitEnable
208 * - CurrentLimitsConfigs#SupplyCurrentLowerLimit
209 * - CurrentLimitsConfigs#SupplyCurrentLowerTime
210 *
211 */
212 CurrentLimitsConfigs CurrentLimits;
213
214 /**
215 * \brief Configs that affect Voltage control types.
216 *
217 * \details Includes peak output voltages and other configs affecting
218 * voltage measurements.
219 *
220 * Parameter list:
221 *
222 * - VoltageConfigs#SupplyVoltageTimeConstant
223 * - VoltageConfigs#PeakForwardVoltage
224 * - VoltageConfigs#PeakReverseVoltage
225 *
226 */
227 VoltageConfigs Voltage;
228
229 /**
230 * \brief Configs that affect Torque Current control types.
231 *
232 * \details Includes the maximum and minimum applied torque output and
233 * the neutral deadband used during TorqueCurrentFOC
234 * requests.
235 *
236 * Parameter list:
237 *
238 * - TorqueCurrentConfigs#PeakForwardTorqueCurrent
239 * - TorqueCurrentConfigs#PeakReverseTorqueCurrent
240 * - TorqueCurrentConfigs#TorqueNeutralDeadband
241 *
242 */
243 TorqueCurrentConfigs TorqueCurrent;
244
245 /**
246 * \brief Configs that affect the feedback of this motor controller.
247 *
248 * \details Includes feedback sensor source, any offsets for the
249 * feedback sensor, and various ratios to describe the
250 * relationship between the sensor and the mechanism for
251 * closed looping.
252 *
253 * Parameter list:
254 *
255 * - FeedbackConfigs#FeedbackRotorOffset
256 * - FeedbackConfigs#SensorToMechanismRatio
257 * - FeedbackConfigs#RotorToSensorRatio
258 * - FeedbackConfigs#FeedbackSensorSource
259 * - FeedbackConfigs#FeedbackRemoteSensorID
260 * - FeedbackConfigs#VelocityFilterTimeConstant
261 *
262 */
263 FeedbackConfigs Feedback;
264
265 /**
266 * \brief Configs related to sensors used for differential control of
267 * a mechanism.
268 *
269 * \details Includes the differential sensor sources and IDs.
270 *
271 * Parameter list:
272 *
273 * - DifferentialSensorsConfigs#DifferentialSensorSource
274 * - DifferentialSensorsConfigs#DifferentialTalonFXSensorID
275 * - DifferentialSensorsConfigs#DifferentialRemoteSensorID
276 * - DifferentialSensorsConfigs#SensorToDifferentialRatio
277 *
278 */
279 DifferentialSensorsConfigs DifferentialSensors;
280
281 /**
282 * \brief Configs related to constants used for differential control
283 * of a mechanism.
284 *
285 * \details Includes the differential peak outputs.
286 *
287 * Parameter list:
288 *
289 * - DifferentialConstantsConfigs#PeakDifferentialDutyCycle
290 * - DifferentialConstantsConfigs#PeakDifferentialVoltage
291 * - DifferentialConstantsConfigs#PeakDifferentialTorqueCurrent
292 *
293 */
294 DifferentialConstantsConfigs DifferentialConstants;
295
296 /**
297 * \brief Configs that affect the open-loop control of this motor
298 * controller.
299 *
300 * \details Open-loop ramp rates for the various control types.
301 *
302 * Parameter list:
303 *
304 * - OpenLoopRampsConfigs#DutyCycleOpenLoopRampPeriod
305 * - OpenLoopRampsConfigs#VoltageOpenLoopRampPeriod
306 * - OpenLoopRampsConfigs#TorqueOpenLoopRampPeriod
307 *
308 */
309 OpenLoopRampsConfigs OpenLoopRamps;
310
311 /**
312 * \brief Configs that affect the closed-loop control of this motor
313 * controller.
314 *
315 * \details Closed-loop ramp rates for the various control types.
316 *
317 * Parameter list:
318 *
319 * - ClosedLoopRampsConfigs#DutyCycleClosedLoopRampPeriod
320 * - ClosedLoopRampsConfigs#VoltageClosedLoopRampPeriod
321 * - ClosedLoopRampsConfigs#TorqueClosedLoopRampPeriod
322 *
323 */
324 ClosedLoopRampsConfigs ClosedLoopRamps;
325
326 /**
327 * \brief Configs that change how the motor controller behaves under
328 * different limit switch states.
329 *
330 * \details Includes configs such as enabling limit switches,
331 * configuring the remote sensor ID, the source, and the
332 * position to set on limit.
333 *
334 * Parameter list:
335 *
336 * - HardwareLimitSwitchConfigs#ForwardLimitType
337 * - HardwareLimitSwitchConfigs#ForwardLimitAutosetPositionEnable
338 * - HardwareLimitSwitchConfigs#ForwardLimitAutosetPositionValue
339 * - HardwareLimitSwitchConfigs#ForwardLimitEnable
340 * - HardwareLimitSwitchConfigs#ForwardLimitSource
341 * - HardwareLimitSwitchConfigs#ForwardLimitRemoteSensorID
342 * - HardwareLimitSwitchConfigs#ReverseLimitType
343 * - HardwareLimitSwitchConfigs#ReverseLimitAutosetPositionEnable
344 * - HardwareLimitSwitchConfigs#ReverseLimitAutosetPositionValue
345 * - HardwareLimitSwitchConfigs#ReverseLimitEnable
346 * - HardwareLimitSwitchConfigs#ReverseLimitSource
347 * - HardwareLimitSwitchConfigs#ReverseLimitRemoteSensorID
348 *
349 */
350 HardwareLimitSwitchConfigs HardwareLimitSwitch;
351
352 /**
353 * \brief Configs that affect audible components of the device.
354 *
355 * \details Includes configuration for the beep on boot.
356 *
357 * Parameter list:
358 *
359 * - AudioConfigs#BeepOnBoot
360 * - AudioConfigs#BeepOnConfig
361 * - AudioConfigs#AllowMusicDurDisable
362 *
363 */
364 AudioConfigs Audio;
365
366 /**
367 * \brief Configs that affect how software-limit switches behave.
368 *
369 * \details Includes enabling software-limit switches and the
370 * threshold at which they are tripped.
371 *
372 * Parameter list:
373 *
374 * - SoftwareLimitSwitchConfigs#ForwardSoftLimitEnable
375 * - SoftwareLimitSwitchConfigs#ReverseSoftLimitEnable
376 * - SoftwareLimitSwitchConfigs#ForwardSoftLimitThreshold
377 * - SoftwareLimitSwitchConfigs#ReverseSoftLimitThreshold
378 *
379 */
380 SoftwareLimitSwitchConfigs SoftwareLimitSwitch;
381
382 /**
383 * \brief Configs for Motion Magic®.
384 *
385 * \details Includes Velocity, Acceleration, Jerk, and Expo
386 * parameters.
387 *
388 * Parameter list:
389 *
390 * - MotionMagicConfigs#MotionMagicCruiseVelocity
391 * - MotionMagicConfigs#MotionMagicAcceleration
392 * - MotionMagicConfigs#MotionMagicJerk
393 * - MotionMagicConfigs#MotionMagicExpo_kV
394 * - MotionMagicConfigs#MotionMagicExpo_kA
395 *
396 */
397 MotionMagicConfigs MotionMagic;
398
399 /**
400 * \brief Custom Params.
401 *
402 * \details Custom paramaters that have no real impact on controller.
403 *
404 * Parameter list:
405 *
406 * - CustomParamsConfigs#CustomParam0
407 * - CustomParamsConfigs#CustomParam1
408 *
409 */
410 CustomParamsConfigs CustomParams;
411
412 /**
413 * \brief Configs that affect general behavior during closed-looping.
414 *
415 * \details Includes Continuous Wrap features.
416 *
417 * Parameter list:
418 *
419 * - ClosedLoopGeneralConfigs#ContinuousWrap
420 * - ClosedLoopGeneralConfigs#DifferentialContinuousWrap
421 * - ClosedLoopGeneralConfigs#GainSchedErrorThreshold
422 * - ClosedLoopGeneralConfigs#GainSchedKpBehavior
423 *
424 */
425 ClosedLoopGeneralConfigs ClosedLoopGeneral;
426
427 /**
428 * \brief Gains for the specified slot.
429 *
430 * \details If this slot is selected, these gains are used in closed
431 * loop control requests.
432 *
433 * Parameter list:
434 *
435 * - Slot0Configs#kP
436 * - Slot0Configs#kI
437 * - Slot0Configs#kD
438 * - Slot0Configs#kS
439 * - Slot0Configs#kV
440 * - Slot0Configs#kA
441 * - Slot0Configs#kG
442 * - Slot0Configs#GravityType
443 * - Slot0Configs#StaticFeedforwardSign
444 * - Slot0Configs#GravityArmPositionOffset
445 * - Slot0Configs#GainSchedBehavior
446 *
447 */
448 Slot0Configs Slot0;
449
450 /**
451 * \brief Gains for the specified slot.
452 *
453 * \details If this slot is selected, these gains are used in closed
454 * loop control requests.
455 *
456 * Parameter list:
457 *
458 * - Slot1Configs#kP
459 * - Slot1Configs#kI
460 * - Slot1Configs#kD
461 * - Slot1Configs#kS
462 * - Slot1Configs#kV
463 * - Slot1Configs#kA
464 * - Slot1Configs#kG
465 * - Slot1Configs#GravityType
466 * - Slot1Configs#StaticFeedforwardSign
467 * - Slot1Configs#GravityArmPositionOffset
468 * - Slot1Configs#GainSchedBehavior
469 *
470 */
471 Slot1Configs Slot1;
472
473 /**
474 * \brief Gains for the specified slot.
475 *
476 * \details If this slot is selected, these gains are used in closed
477 * loop control requests.
478 *
479 * Parameter list:
480 *
481 * - Slot2Configs#kP
482 * - Slot2Configs#kI
483 * - Slot2Configs#kD
484 * - Slot2Configs#kS
485 * - Slot2Configs#kV
486 * - Slot2Configs#kA
487 * - Slot2Configs#kG
488 * - Slot2Configs#GravityType
489 * - Slot2Configs#StaticFeedforwardSign
490 * - Slot2Configs#GravityArmPositionOffset
491 * - Slot2Configs#GainSchedBehavior
492 *
493 */
494 Slot2Configs Slot2;
495
496 /**
497 * \brief Modifies this configuration's MotorOutput parameter and returns itself for
498 * method-chaining and easier to use config API.
499 *
500 * Configs that directly affect motor output.
501 *
502 * \details Includes motor invert, neutral mode, and other features
503 * related to motor output.
504 *
505 * Parameter list:
506 *
507 * - MotorOutputConfigs#Inverted
508 * - MotorOutputConfigs#NeutralMode
509 * - MotorOutputConfigs#DutyCycleNeutralDeadband
510 * - MotorOutputConfigs#PeakForwardDutyCycle
511 * - MotorOutputConfigs#PeakReverseDutyCycle
512 * - MotorOutputConfigs#ControlTimesyncFreqHz
513 *
514 *
515 * \param newMotorOutput Parameter to modify
516 * \returns Itself
517 */
518 constexpr TalonFXConfiguration &WithMotorOutput(MotorOutputConfigs newMotorOutput)
519 {
520 MotorOutput = std::move(newMotorOutput);
521 return *this;
522 }
523
524 /**
525 * \brief Modifies this configuration's CurrentLimits parameter and returns itself for
526 * method-chaining and easier to use config API.
527 *
528 * Configs that directly affect current limiting features.
529 *
530 * \details Contains the supply/stator current limit thresholds and
531 * whether to enable them.
532 *
533 * Parameter list:
534 *
535 * - CurrentLimitsConfigs#StatorCurrentLimit
536 * - CurrentLimitsConfigs#StatorCurrentLimitEnable
537 * - CurrentLimitsConfigs#SupplyCurrentLimit
538 * - CurrentLimitsConfigs#SupplyCurrentLimitEnable
539 * - CurrentLimitsConfigs#SupplyCurrentLowerLimit
540 * - CurrentLimitsConfigs#SupplyCurrentLowerTime
541 *
542 *
543 * \param newCurrentLimits Parameter to modify
544 * \returns Itself
545 */
546 constexpr TalonFXConfiguration &WithCurrentLimits(CurrentLimitsConfigs newCurrentLimits)
547 {
548 CurrentLimits = std::move(newCurrentLimits);
549 return *this;
550 }
551
552 /**
553 * \brief Modifies this configuration's Voltage parameter and returns itself for
554 * method-chaining and easier to use config API.
555 *
556 * Configs that affect Voltage control types.
557 *
558 * \details Includes peak output voltages and other configs affecting
559 * voltage measurements.
560 *
561 * Parameter list:
562 *
563 * - VoltageConfigs#SupplyVoltageTimeConstant
564 * - VoltageConfigs#PeakForwardVoltage
565 * - VoltageConfigs#PeakReverseVoltage
566 *
567 *
568 * \param newVoltage Parameter to modify
569 * \returns Itself
570 */
571 constexpr TalonFXConfiguration &WithVoltage(VoltageConfigs newVoltage)
572 {
573 Voltage = std::move(newVoltage);
574 return *this;
575 }
576
577 /**
578 * \brief Modifies this configuration's TorqueCurrent parameter and returns itself for
579 * method-chaining and easier to use config API.
580 *
581 * Configs that affect Torque Current control types.
582 *
583 * \details Includes the maximum and minimum applied torque output and
584 * the neutral deadband used during TorqueCurrentFOC
585 * requests.
586 *
587 * Parameter list:
588 *
589 * - TorqueCurrentConfigs#PeakForwardTorqueCurrent
590 * - TorqueCurrentConfigs#PeakReverseTorqueCurrent
591 * - TorqueCurrentConfigs#TorqueNeutralDeadband
592 *
593 *
594 * \param newTorqueCurrent Parameter to modify
595 * \returns Itself
596 */
597 constexpr TalonFXConfiguration &WithTorqueCurrent(TorqueCurrentConfigs newTorqueCurrent)
598 {
599 TorqueCurrent = std::move(newTorqueCurrent);
600 return *this;
601 }
602
603 /**
604 * \brief Modifies this configuration's Feedback parameter and returns itself for
605 * method-chaining and easier to use config API.
606 *
607 * Configs that affect the feedback of this motor controller.
608 *
609 * \details Includes feedback sensor source, any offsets for the
610 * feedback sensor, and various ratios to describe the
611 * relationship between the sensor and the mechanism for
612 * closed looping.
613 *
614 * Parameter list:
615 *
616 * - FeedbackConfigs#FeedbackRotorOffset
617 * - FeedbackConfigs#SensorToMechanismRatio
618 * - FeedbackConfigs#RotorToSensorRatio
619 * - FeedbackConfigs#FeedbackSensorSource
620 * - FeedbackConfigs#FeedbackRemoteSensorID
621 * - FeedbackConfigs#VelocityFilterTimeConstant
622 *
623 *
624 * \param newFeedback Parameter to modify
625 * \returns Itself
626 */
627 constexpr TalonFXConfiguration &WithFeedback(FeedbackConfigs newFeedback)
628 {
629 Feedback = std::move(newFeedback);
630 return *this;
631 }
632
633 /**
634 * \brief Modifies this configuration's DifferentialSensors parameter and returns itself for
635 * method-chaining and easier to use config API.
636 *
637 * Configs related to sensors used for differential control of a
638 * mechanism.
639 *
640 * \details Includes the differential sensor sources and IDs.
641 *
642 * Parameter list:
643 *
644 * - DifferentialSensorsConfigs#DifferentialSensorSource
645 * - DifferentialSensorsConfigs#DifferentialTalonFXSensorID
646 * - DifferentialSensorsConfigs#DifferentialRemoteSensorID
647 * - DifferentialSensorsConfigs#SensorToDifferentialRatio
648 *
649 *
650 * \param newDifferentialSensors Parameter to modify
651 * \returns Itself
652 */
653 constexpr TalonFXConfiguration &WithDifferentialSensors(DifferentialSensorsConfigs newDifferentialSensors)
654 {
655 DifferentialSensors = std::move(newDifferentialSensors);
656 return *this;
657 }
658
659 /**
660 * \brief Modifies this configuration's DifferentialConstants parameter and returns itself for
661 * method-chaining and easier to use config API.
662 *
663 * Configs related to constants used for differential control of a
664 * mechanism.
665 *
666 * \details Includes the differential peak outputs.
667 *
668 * Parameter list:
669 *
670 * - DifferentialConstantsConfigs#PeakDifferentialDutyCycle
671 * - DifferentialConstantsConfigs#PeakDifferentialVoltage
672 * - DifferentialConstantsConfigs#PeakDifferentialTorqueCurrent
673 *
674 *
675 * \param newDifferentialConstants Parameter to modify
676 * \returns Itself
677 */
678 constexpr TalonFXConfiguration &WithDifferentialConstants(DifferentialConstantsConfigs newDifferentialConstants)
679 {
680 DifferentialConstants = std::move(newDifferentialConstants);
681 return *this;
682 }
683
684 /**
685 * \brief Modifies this configuration's OpenLoopRamps parameter and returns itself for
686 * method-chaining and easier to use config API.
687 *
688 * Configs that affect the open-loop control of this motor controller.
689 *
690 * \details Open-loop ramp rates for the various control types.
691 *
692 * Parameter list:
693 *
694 * - OpenLoopRampsConfigs#DutyCycleOpenLoopRampPeriod
695 * - OpenLoopRampsConfigs#VoltageOpenLoopRampPeriod
696 * - OpenLoopRampsConfigs#TorqueOpenLoopRampPeriod
697 *
698 *
699 * \param newOpenLoopRamps Parameter to modify
700 * \returns Itself
701 */
702 constexpr TalonFXConfiguration &WithOpenLoopRamps(OpenLoopRampsConfigs newOpenLoopRamps)
703 {
704 OpenLoopRamps = std::move(newOpenLoopRamps);
705 return *this;
706 }
707
708 /**
709 * \brief Modifies this configuration's ClosedLoopRamps parameter and returns itself for
710 * method-chaining and easier to use config API.
711 *
712 * Configs that affect the closed-loop control of this motor
713 * controller.
714 *
715 * \details Closed-loop ramp rates for the various control types.
716 *
717 * Parameter list:
718 *
719 * - ClosedLoopRampsConfigs#DutyCycleClosedLoopRampPeriod
720 * - ClosedLoopRampsConfigs#VoltageClosedLoopRampPeriod
721 * - ClosedLoopRampsConfigs#TorqueClosedLoopRampPeriod
722 *
723 *
724 * \param newClosedLoopRamps Parameter to modify
725 * \returns Itself
726 */
727 constexpr TalonFXConfiguration &WithClosedLoopRamps(ClosedLoopRampsConfigs newClosedLoopRamps)
728 {
729 ClosedLoopRamps = std::move(newClosedLoopRamps);
730 return *this;
731 }
732
733 /**
734 * \brief Modifies this configuration's HardwareLimitSwitch parameter and returns itself for
735 * method-chaining and easier to use config API.
736 *
737 * Configs that change how the motor controller behaves under
738 * different limit switch states.
739 *
740 * \details Includes configs such as enabling limit switches,
741 * configuring the remote sensor ID, the source, and the
742 * position to set on limit.
743 *
744 * Parameter list:
745 *
746 * - HardwareLimitSwitchConfigs#ForwardLimitType
747 * - HardwareLimitSwitchConfigs#ForwardLimitAutosetPositionEnable
748 * - HardwareLimitSwitchConfigs#ForwardLimitAutosetPositionValue
749 * - HardwareLimitSwitchConfigs#ForwardLimitEnable
750 * - HardwareLimitSwitchConfigs#ForwardLimitSource
751 * - HardwareLimitSwitchConfigs#ForwardLimitRemoteSensorID
752 * - HardwareLimitSwitchConfigs#ReverseLimitType
753 * - HardwareLimitSwitchConfigs#ReverseLimitAutosetPositionEnable
754 * - HardwareLimitSwitchConfigs#ReverseLimitAutosetPositionValue
755 * - HardwareLimitSwitchConfigs#ReverseLimitEnable
756 * - HardwareLimitSwitchConfigs#ReverseLimitSource
757 * - HardwareLimitSwitchConfigs#ReverseLimitRemoteSensorID
758 *
759 *
760 * \param newHardwareLimitSwitch Parameter to modify
761 * \returns Itself
762 */
763 constexpr TalonFXConfiguration &WithHardwareLimitSwitch(HardwareLimitSwitchConfigs newHardwareLimitSwitch)
764 {
765 HardwareLimitSwitch = std::move(newHardwareLimitSwitch);
766 return *this;
767 }
768
769 /**
770 * \brief Modifies this configuration's Audio parameter and returns itself for
771 * method-chaining and easier to use config API.
772 *
773 * Configs that affect audible components of the device.
774 *
775 * \details Includes configuration for the beep on boot.
776 *
777 * Parameter list:
778 *
779 * - AudioConfigs#BeepOnBoot
780 * - AudioConfigs#BeepOnConfig
781 * - AudioConfigs#AllowMusicDurDisable
782 *
783 *
784 * \param newAudio Parameter to modify
785 * \returns Itself
786 */
787 constexpr TalonFXConfiguration &WithAudio(AudioConfigs newAudio)
788 {
789 Audio = std::move(newAudio);
790 return *this;
791 }
792
793 /**
794 * \brief Modifies this configuration's SoftwareLimitSwitch parameter and returns itself for
795 * method-chaining and easier to use config API.
796 *
797 * Configs that affect how software-limit switches behave.
798 *
799 * \details Includes enabling software-limit switches and the
800 * threshold at which they are tripped.
801 *
802 * Parameter list:
803 *
804 * - SoftwareLimitSwitchConfigs#ForwardSoftLimitEnable
805 * - SoftwareLimitSwitchConfigs#ReverseSoftLimitEnable
806 * - SoftwareLimitSwitchConfigs#ForwardSoftLimitThreshold
807 * - SoftwareLimitSwitchConfigs#ReverseSoftLimitThreshold
808 *
809 *
810 * \param newSoftwareLimitSwitch Parameter to modify
811 * \returns Itself
812 */
813 constexpr TalonFXConfiguration &WithSoftwareLimitSwitch(SoftwareLimitSwitchConfigs newSoftwareLimitSwitch)
814 {
815 SoftwareLimitSwitch = std::move(newSoftwareLimitSwitch);
816 return *this;
817 }
818
819 /**
820 * \brief Modifies this configuration's MotionMagic parameter and returns itself for
821 * method-chaining and easier to use config API.
822 *
823 * Configs for Motion Magic®.
824 *
825 * \details Includes Velocity, Acceleration, Jerk, and Expo
826 * parameters.
827 *
828 * Parameter list:
829 *
830 * - MotionMagicConfigs#MotionMagicCruiseVelocity
831 * - MotionMagicConfigs#MotionMagicAcceleration
832 * - MotionMagicConfigs#MotionMagicJerk
833 * - MotionMagicConfigs#MotionMagicExpo_kV
834 * - MotionMagicConfigs#MotionMagicExpo_kA
835 *
836 *
837 * \param newMotionMagic Parameter to modify
838 * \returns Itself
839 */
840 constexpr TalonFXConfiguration &WithMotionMagic(MotionMagicConfigs newMotionMagic)
841 {
842 MotionMagic = std::move(newMotionMagic);
843 return *this;
844 }
845
846 /**
847 * \brief Modifies this configuration's CustomParams parameter and returns itself for
848 * method-chaining and easier to use config API.
849 *
850 * Custom Params.
851 *
852 * \details Custom paramaters that have no real impact on controller.
853 *
854 * Parameter list:
855 *
856 * - CustomParamsConfigs#CustomParam0
857 * - CustomParamsConfigs#CustomParam1
858 *
859 *
860 * \param newCustomParams Parameter to modify
861 * \returns Itself
862 */
863 constexpr TalonFXConfiguration &WithCustomParams(CustomParamsConfigs newCustomParams)
864 {
865 CustomParams = std::move(newCustomParams);
866 return *this;
867 }
868
869 /**
870 * \brief Modifies this configuration's ClosedLoopGeneral parameter and returns itself for
871 * method-chaining and easier to use config API.
872 *
873 * Configs that affect general behavior during closed-looping.
874 *
875 * \details Includes Continuous Wrap features.
876 *
877 * Parameter list:
878 *
879 * - ClosedLoopGeneralConfigs#ContinuousWrap
880 * - ClosedLoopGeneralConfigs#DifferentialContinuousWrap
881 * - ClosedLoopGeneralConfigs#GainSchedErrorThreshold
882 * - ClosedLoopGeneralConfigs#GainSchedKpBehavior
883 *
884 *
885 * \param newClosedLoopGeneral Parameter to modify
886 * \returns Itself
887 */
888 constexpr TalonFXConfiguration &WithClosedLoopGeneral(ClosedLoopGeneralConfigs newClosedLoopGeneral)
889 {
890 ClosedLoopGeneral = std::move(newClosedLoopGeneral);
891 return *this;
892 }
893
894 /**
895 * \brief Modifies this configuration's Slot0 parameter and returns itself for
896 * method-chaining and easier to use config API.
897 *
898 * Gains for the specified slot.
899 *
900 * \details If this slot is selected, these gains are used in closed
901 * loop control requests.
902 *
903 * Parameter list:
904 *
905 * - Slot0Configs#kP
906 * - Slot0Configs#kI
907 * - Slot0Configs#kD
908 * - Slot0Configs#kS
909 * - Slot0Configs#kV
910 * - Slot0Configs#kA
911 * - Slot0Configs#kG
912 * - Slot0Configs#GravityType
913 * - Slot0Configs#StaticFeedforwardSign
914 * - Slot0Configs#GravityArmPositionOffset
915 * - Slot0Configs#GainSchedBehavior
916 *
917 *
918 * \param newSlot0 Parameter to modify
919 * \returns Itself
920 */
921 constexpr TalonFXConfiguration &WithSlot0(Slot0Configs newSlot0)
922 {
923 Slot0 = std::move(newSlot0);
924 return *this;
925 }
926
927 /**
928 * \brief Modifies this configuration's Slot1 parameter and returns itself for
929 * method-chaining and easier to use config API.
930 *
931 * Gains for the specified slot.
932 *
933 * \details If this slot is selected, these gains are used in closed
934 * loop control requests.
935 *
936 * Parameter list:
937 *
938 * - Slot1Configs#kP
939 * - Slot1Configs#kI
940 * - Slot1Configs#kD
941 * - Slot1Configs#kS
942 * - Slot1Configs#kV
943 * - Slot1Configs#kA
944 * - Slot1Configs#kG
945 * - Slot1Configs#GravityType
946 * - Slot1Configs#StaticFeedforwardSign
947 * - Slot1Configs#GravityArmPositionOffset
948 * - Slot1Configs#GainSchedBehavior
949 *
950 *
951 * \param newSlot1 Parameter to modify
952 * \returns Itself
953 */
954 constexpr TalonFXConfiguration &WithSlot1(Slot1Configs newSlot1)
955 {
956 Slot1 = std::move(newSlot1);
957 return *this;
958 }
959
960 /**
961 * \brief Modifies this configuration's Slot2 parameter and returns itself for
962 * method-chaining and easier to use config API.
963 *
964 * Gains for the specified slot.
965 *
966 * \details If this slot is selected, these gains are used in closed
967 * loop control requests.
968 *
969 * Parameter list:
970 *
971 * - Slot2Configs#kP
972 * - Slot2Configs#kI
973 * - Slot2Configs#kD
974 * - Slot2Configs#kS
975 * - Slot2Configs#kV
976 * - Slot2Configs#kA
977 * - Slot2Configs#kG
978 * - Slot2Configs#GravityType
979 * - Slot2Configs#StaticFeedforwardSign
980 * - Slot2Configs#GravityArmPositionOffset
981 * - Slot2Configs#GainSchedBehavior
982 *
983 *
984 * \param newSlot2 Parameter to modify
985 * \returns Itself
986 */
987 constexpr TalonFXConfiguration &WithSlot2(Slot2Configs newSlot2)
988 {
989 Slot2 = std::move(newSlot2);
990 return *this;
991 }
992
993 /**
994 * \brief Get the string representation of this configuration
995 */
996 std::string ToString() const override;
997
998 /**
999 * \brief Get the serialized form of this configuration
1000 */
1001 std::string Serialize() const final;
1002 /**
1003 * \brief Take a string and deserialize it to this configuration
1004 */
1005 ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final;
1006};
1007
1008/**
1009 * Class description for the Talon FX integrated motor controller.
1010 *
1011 * This handles applying and refreshing configurations for the hardware#TalonFX.
1012 */
1013class TalonFXConfigurator : public ParentConfigurator
1014{
1015private:
1016 TalonFXConfigurator(hardware::DeviceIdentifier id) :
1017 ParentConfigurator{std::move(id)}
1018 {}
1019
1020 friend hardware::core::CoreTalonFX;
1021
1022public:
1023 /**
1024 * \brief Applies the contents of the specified config to the device.
1025 *
1026 * This will wait up to #DefaultTimeoutSeconds.
1027 *
1028 * \details Call to apply the selected configs.
1029 *
1030 * \param configs Configs to apply against.
1031 * \returns Status code of applying the configs
1032 */
1033 ctre::phoenix::StatusCode Apply(const TalonFXConfiguration &configs)
1034 {
1035 return Apply(configs, DefaultTimeoutSeconds);
1036 }
1037
1038 /**
1039 * \brief Applies the contents of the specified config to the device.
1040 *
1041 * \details Call to apply the selected configs.
1042 *
1043 * \param configs Configs to apply against.
1044 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1045 * \returns Status code of applying the configs
1046 */
1047 ctre::phoenix::StatusCode Apply(const TalonFXConfiguration &configs, units::time::second_t timeoutSeconds)
1048 {
1049 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, configs.FutureProofConfigs, false);
1050 }
1051
1052 /**
1053 * \brief Applies the contents of the specified config to the device.
1054 *
1055 * This will wait up to #DefaultTimeoutSeconds.
1056 *
1057 * \details Call to apply the selected configs.
1058 *
1059 * \param configs Configs to apply against.
1060 * \returns Status code of applying the configs
1061 */
1062 ctre::phoenix::StatusCode Apply(const MotorOutputConfigs &configs)
1063 {
1064 return Apply(configs, DefaultTimeoutSeconds);
1065 }
1066
1067 /**
1068 * \brief Applies the contents of the specified config to the device.
1069 *
1070 * \details Call to apply the selected configs.
1071 *
1072 * \param configs Configs to apply against.
1073 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1074 * \returns Status code of applying the configs
1075 */
1076 ctre::phoenix::StatusCode Apply(const MotorOutputConfigs &configs, units::time::second_t timeoutSeconds)
1077 {
1078 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1079 }
1080
1081 /**
1082 * \brief Applies the contents of the specified config to the device.
1083 *
1084 * This will wait up to #DefaultTimeoutSeconds.
1085 *
1086 * \details Call to apply the selected configs.
1087 *
1088 * \param configs Configs to apply against.
1089 * \returns Status code of applying the configs
1090 */
1091 ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs &configs)
1092 {
1093 return Apply(configs, DefaultTimeoutSeconds);
1094 }
1095
1096 /**
1097 * \brief Applies the contents of the specified config to the device.
1098 *
1099 * \details Call to apply the selected configs.
1100 *
1101 * \param configs Configs to apply against.
1102 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1103 * \returns Status code of applying the configs
1104 */
1105 ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs &configs, units::time::second_t timeoutSeconds)
1106 {
1107 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1108 }
1109
1110 /**
1111 * \brief Applies the contents of the specified config to the device.
1112 *
1113 * This will wait up to #DefaultTimeoutSeconds.
1114 *
1115 * \details Call to apply the selected configs.
1116 *
1117 * \param configs Configs to apply against.
1118 * \returns Status code of applying the configs
1119 */
1120 ctre::phoenix::StatusCode Apply(const VoltageConfigs &configs)
1121 {
1122 return Apply(configs, DefaultTimeoutSeconds);
1123 }
1124
1125 /**
1126 * \brief Applies the contents of the specified config to the device.
1127 *
1128 * \details Call to apply the selected configs.
1129 *
1130 * \param configs Configs to apply against.
1131 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1132 * \returns Status code of applying the configs
1133 */
1134 ctre::phoenix::StatusCode Apply(const VoltageConfigs &configs, units::time::second_t timeoutSeconds)
1135 {
1136 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1137 }
1138
1139 /**
1140 * \brief Applies the contents of the specified config to the device.
1141 *
1142 * This will wait up to #DefaultTimeoutSeconds.
1143 *
1144 * \details Call to apply the selected configs.
1145 *
1146 * \param configs Configs to apply against.
1147 * \returns Status code of applying the configs
1148 */
1149 ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs &configs)
1150 {
1151 return Apply(configs, DefaultTimeoutSeconds);
1152 }
1153
1154 /**
1155 * \brief Applies the contents of the specified config to the device.
1156 *
1157 * \details Call to apply the selected configs.
1158 *
1159 * \param configs Configs to apply against.
1160 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1161 * \returns Status code of applying the configs
1162 */
1163 ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs &configs, units::time::second_t timeoutSeconds)
1164 {
1165 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1166 }
1167
1168 /**
1169 * \brief Applies the contents of the specified config to the device.
1170 *
1171 * This will wait up to #DefaultTimeoutSeconds.
1172 *
1173 * \details Call to apply the selected configs.
1174 *
1175 * \param configs Configs to apply against.
1176 * \returns Status code of applying the configs
1177 */
1178 ctre::phoenix::StatusCode Apply(const FeedbackConfigs &configs)
1179 {
1180 return Apply(configs, DefaultTimeoutSeconds);
1181 }
1182
1183 /**
1184 * \brief Applies the contents of the specified config to the device.
1185 *
1186 * \details Call to apply the selected configs.
1187 *
1188 * \param configs Configs to apply against.
1189 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1190 * \returns Status code of applying the configs
1191 */
1192 ctre::phoenix::StatusCode Apply(const FeedbackConfigs &configs, units::time::second_t timeoutSeconds)
1193 {
1194 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1195 }
1196
1197 /**
1198 * \brief Applies the contents of the specified config to the device.
1199 *
1200 * This will wait up to #DefaultTimeoutSeconds.
1201 *
1202 * \details Call to apply the selected configs.
1203 *
1204 * \param configs Configs to apply against.
1205 * \returns Status code of applying the configs
1206 */
1207 ctre::phoenix::StatusCode Apply(const DifferentialSensorsConfigs &configs)
1208 {
1209 return Apply(configs, DefaultTimeoutSeconds);
1210 }
1211
1212 /**
1213 * \brief Applies the contents of the specified config to the device.
1214 *
1215 * \details Call to apply the selected configs.
1216 *
1217 * \param configs Configs to apply against.
1218 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1219 * \returns Status code of applying the configs
1220 */
1221 ctre::phoenix::StatusCode Apply(const DifferentialSensorsConfigs &configs, units::time::second_t timeoutSeconds)
1222 {
1223 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1224 }
1225
1226 /**
1227 * \brief Applies the contents of the specified config to the device.
1228 *
1229 * This will wait up to #DefaultTimeoutSeconds.
1230 *
1231 * \details Call to apply the selected configs.
1232 *
1233 * \param configs Configs to apply against.
1234 * \returns Status code of applying the configs
1235 */
1236 ctre::phoenix::StatusCode Apply(const DifferentialConstantsConfigs &configs)
1237 {
1238 return Apply(configs, DefaultTimeoutSeconds);
1239 }
1240
1241 /**
1242 * \brief Applies the contents of the specified config to the device.
1243 *
1244 * \details Call to apply the selected configs.
1245 *
1246 * \param configs Configs to apply against.
1247 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1248 * \returns Status code of applying the configs
1249 */
1250 ctre::phoenix::StatusCode Apply(const DifferentialConstantsConfigs &configs, units::time::second_t timeoutSeconds)
1251 {
1252 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1253 }
1254
1255 /**
1256 * \brief Applies the contents of the specified config to the device.
1257 *
1258 * This will wait up to #DefaultTimeoutSeconds.
1259 *
1260 * \details Call to apply the selected configs.
1261 *
1262 * \param configs Configs to apply against.
1263 * \returns Status code of applying the configs
1264 */
1265 ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs &configs)
1266 {
1267 return Apply(configs, DefaultTimeoutSeconds);
1268 }
1269
1270 /**
1271 * \brief Applies the contents of the specified config to the device.
1272 *
1273 * \details Call to apply the selected configs.
1274 *
1275 * \param configs Configs to apply against.
1276 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1277 * \returns Status code of applying the configs
1278 */
1279 ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs &configs, units::time::second_t timeoutSeconds)
1280 {
1281 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1282 }
1283
1284 /**
1285 * \brief Applies the contents of the specified config to the device.
1286 *
1287 * This will wait up to #DefaultTimeoutSeconds.
1288 *
1289 * \details Call to apply the selected configs.
1290 *
1291 * \param configs Configs to apply against.
1292 * \returns Status code of applying the configs
1293 */
1294 ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs &configs)
1295 {
1296 return Apply(configs, DefaultTimeoutSeconds);
1297 }
1298
1299 /**
1300 * \brief Applies the contents of the specified config to the device.
1301 *
1302 * \details Call to apply the selected configs.
1303 *
1304 * \param configs Configs to apply against.
1305 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1306 * \returns Status code of applying the configs
1307 */
1308 ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs &configs, units::time::second_t timeoutSeconds)
1309 {
1310 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1311 }
1312
1313 /**
1314 * \brief Applies the contents of the specified config to the device.
1315 *
1316 * This will wait up to #DefaultTimeoutSeconds.
1317 *
1318 * \details Call to apply the selected configs.
1319 *
1320 * \param configs Configs to apply against.
1321 * \returns Status code of applying the configs
1322 */
1323 ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs &configs)
1324 {
1325 return Apply(configs, DefaultTimeoutSeconds);
1326 }
1327
1328 /**
1329 * \brief Applies the contents of the specified config to the device.
1330 *
1331 * \details Call to apply the selected configs.
1332 *
1333 * \param configs Configs to apply against.
1334 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1335 * \returns Status code of applying the configs
1336 */
1337 ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds)
1338 {
1339 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1340 }
1341
1342 /**
1343 * \brief Applies the contents of the specified config to the device.
1344 *
1345 * This will wait up to #DefaultTimeoutSeconds.
1346 *
1347 * \details Call to apply the selected configs.
1348 *
1349 * \param configs Configs to apply against.
1350 * \returns Status code of applying the configs
1351 */
1352 ctre::phoenix::StatusCode Apply(const AudioConfigs &configs)
1353 {
1354 return Apply(configs, DefaultTimeoutSeconds);
1355 }
1356
1357 /**
1358 * \brief Applies the contents of the specified config to the device.
1359 *
1360 * \details Call to apply the selected configs.
1361 *
1362 * \param configs Configs to apply against.
1363 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1364 * \returns Status code of applying the configs
1365 */
1366 ctre::phoenix::StatusCode Apply(const AudioConfigs &configs, units::time::second_t timeoutSeconds)
1367 {
1368 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1369 }
1370
1371 /**
1372 * \brief Applies the contents of the specified config to the device.
1373 *
1374 * This will wait up to #DefaultTimeoutSeconds.
1375 *
1376 * \details Call to apply the selected configs.
1377 *
1378 * \param configs Configs to apply against.
1379 * \returns Status code of applying the configs
1380 */
1381 ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs &configs)
1382 {
1383 return Apply(configs, DefaultTimeoutSeconds);
1384 }
1385
1386 /**
1387 * \brief Applies the contents of the specified config to the device.
1388 *
1389 * \details Call to apply the selected configs.
1390 *
1391 * \param configs Configs to apply against.
1392 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1393 * \returns Status code of applying the configs
1394 */
1395 ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds)
1396 {
1397 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1398 }
1399
1400 /**
1401 * \brief Applies the contents of the specified config to the device.
1402 *
1403 * This will wait up to #DefaultTimeoutSeconds.
1404 *
1405 * \details Call to apply the selected configs.
1406 *
1407 * \param configs Configs to apply against.
1408 * \returns Status code of applying the configs
1409 */
1410 ctre::phoenix::StatusCode Apply(const MotionMagicConfigs &configs)
1411 {
1412 return Apply(configs, DefaultTimeoutSeconds);
1413 }
1414
1415 /**
1416 * \brief Applies the contents of the specified config to the device.
1417 *
1418 * \details Call to apply the selected configs.
1419 *
1420 * \param configs Configs to apply against.
1421 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1422 * \returns Status code of applying the configs
1423 */
1424 ctre::phoenix::StatusCode Apply(const MotionMagicConfigs &configs, units::time::second_t timeoutSeconds)
1425 {
1426 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1427 }
1428
1429 /**
1430 * \brief Applies the contents of the specified config to the device.
1431 *
1432 * This will wait up to #DefaultTimeoutSeconds.
1433 *
1434 * \details Call to apply the selected configs.
1435 *
1436 * \param configs Configs to apply against.
1437 * \returns Status code of applying the configs
1438 */
1439 ctre::phoenix::StatusCode Apply(const CustomParamsConfigs &configs)
1440 {
1441 return Apply(configs, DefaultTimeoutSeconds);
1442 }
1443
1444 /**
1445 * \brief Applies the contents of the specified config to the device.
1446 *
1447 * \details Call to apply the selected configs.
1448 *
1449 * \param configs Configs to apply against.
1450 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1451 * \returns Status code of applying the configs
1452 */
1453 ctre::phoenix::StatusCode Apply(const CustomParamsConfigs &configs, units::time::second_t timeoutSeconds)
1454 {
1455 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1456 }
1457
1458 /**
1459 * \brief Applies the contents of the specified config to the device.
1460 *
1461 * This will wait up to #DefaultTimeoutSeconds.
1462 *
1463 * \details Call to apply the selected configs.
1464 *
1465 * \param configs Configs to apply against.
1466 * \returns Status code of applying the configs
1467 */
1468 ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs &configs)
1469 {
1470 return Apply(configs, DefaultTimeoutSeconds);
1471 }
1472
1473 /**
1474 * \brief Applies the contents of the specified config to the device.
1475 *
1476 * \details Call to apply the selected configs.
1477 *
1478 * \param configs Configs to apply against.
1479 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1480 * \returns Status code of applying the configs
1481 */
1482 ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs &configs, units::time::second_t timeoutSeconds)
1483 {
1484 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1485 }
1486
1487 /**
1488 * \brief Applies the contents of the specified config to the device.
1489 *
1490 * This will wait up to #DefaultTimeoutSeconds.
1491 *
1492 * \details Call to apply the selected configs.
1493 *
1494 * \param configs Configs to apply against.
1495 * \returns Status code of applying the configs
1496 */
1497 ctre::phoenix::StatusCode Apply(const Slot0Configs &configs)
1498 {
1499 return Apply(configs, DefaultTimeoutSeconds);
1500 }
1501
1502 /**
1503 * \brief Applies the contents of the specified config to the device.
1504 *
1505 * \details Call to apply the selected configs.
1506 *
1507 * \param configs Configs to apply against.
1508 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1509 * \returns Status code of applying the configs
1510 */
1511 ctre::phoenix::StatusCode Apply(const Slot0Configs &configs, units::time::second_t timeoutSeconds)
1512 {
1513 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1514 }
1515
1516 /**
1517 * \brief Applies the contents of the specified config to the device.
1518 *
1519 * This will wait up to #DefaultTimeoutSeconds.
1520 *
1521 * \details Call to apply the selected configs.
1522 *
1523 * \param configs Configs to apply against.
1524 * \returns Status code of applying the configs
1525 */
1526 ctre::phoenix::StatusCode Apply(const Slot1Configs &configs)
1527 {
1528 return Apply(configs, DefaultTimeoutSeconds);
1529 }
1530
1531 /**
1532 * \brief Applies the contents of the specified config to the device.
1533 *
1534 * \details Call to apply the selected configs.
1535 *
1536 * \param configs Configs to apply against.
1537 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1538 * \returns Status code of applying the configs
1539 */
1540 ctre::phoenix::StatusCode Apply(const Slot1Configs &configs, units::time::second_t timeoutSeconds)
1541 {
1542 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1543 }
1544
1545 /**
1546 * \brief Applies the contents of the specified config to the device.
1547 *
1548 * This will wait up to #DefaultTimeoutSeconds.
1549 *
1550 * \details Call to apply the selected configs.
1551 *
1552 * \param configs Configs to apply against.
1553 * \returns Status code of applying the configs
1554 */
1555 ctre::phoenix::StatusCode Apply(const Slot2Configs &configs)
1556 {
1557 return Apply(configs, DefaultTimeoutSeconds);
1558 }
1559
1560 /**
1561 * \brief Applies the contents of the specified config to the device.
1562 *
1563 * \details Call to apply the selected configs.
1564 *
1565 * \param configs Configs to apply against.
1566 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1567 * \returns Status code of applying the configs
1568 */
1569 ctre::phoenix::StatusCode Apply(const Slot2Configs &configs, units::time::second_t timeoutSeconds)
1570 {
1571 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1572 }
1573
1574 /**
1575 * \brief Applies the contents of the specified config to the device.
1576 *
1577 * This will wait up to #DefaultTimeoutSeconds.
1578 *
1579 * \details Call to apply the selected configs.
1580 *
1581 * \param configs Configs to apply against.
1582 * \returns Status code of applying the configs
1583 */
1584 ctre::phoenix::StatusCode Apply(const SlotConfigs &configs)
1585 {
1586 return Apply(configs, DefaultTimeoutSeconds);
1587 }
1588
1589 /**
1590 * \brief Applies the contents of the specified config to the device.
1591 *
1592 * \details Call to apply the selected configs.
1593 *
1594 * \param configs Configs to apply against.
1595 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1596 * \returns Status code of applying the configs
1597 */
1598 ctre::phoenix::StatusCode Apply(const SlotConfigs &configs, units::time::second_t timeoutSeconds)
1599 {
1600 return SetConfigsPrivate(configs.Serialize(), timeoutSeconds, false, false);
1601 }
1602
1603 /**
1604 * \brief Refreshes the values of the specified config group.
1605 *
1606 * This will wait up to #DefaultTimeoutSeconds.
1607 *
1608 * \details Call to refresh the selected configs from the device.
1609 *
1610 * \param configs The configs to refresh
1611 * \returns Status code of refreshing the configs
1612 */
1613 ctre::phoenix::StatusCode Refresh(TalonFXConfiguration &configs) const
1614 {
1615 return Refresh(configs, DefaultTimeoutSeconds);
1616 }
1617
1618 /**
1619 * \brief Refreshes the values of the specified config group.
1620 *
1621 * \details Call to refresh the selected configs from the device.
1622 *
1623 * \param configs The configs to refresh
1624 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1625 * \returns Status code of refreshing the configs
1626 */
1627 ctre::phoenix::StatusCode Refresh(TalonFXConfiguration &configs, units::time::second_t timeoutSeconds) const
1628 {
1629 std::string ref;
1630 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1631 configs.Deserialize(ref);
1632 return ret;
1633 }
1634
1635 /**
1636 * \brief Refreshes the values of the specified config group.
1637 *
1638 * This will wait up to #DefaultTimeoutSeconds.
1639 *
1640 * \details Call to refresh the selected configs from the device.
1641 *
1642 * \param configs The configs to refresh
1643 * \returns Status code of refreshing the configs
1644 */
1645 ctre::phoenix::StatusCode Refresh(MotorOutputConfigs &configs) const
1646 {
1647 return Refresh(configs, DefaultTimeoutSeconds);
1648 }
1649 /**
1650 * \brief Refreshes the values of the specified config group.
1651 *
1652 * \details Call to refresh the selected configs from the device.
1653 *
1654 * \param configs The configs to refresh
1655 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1656 * \returns Status code of refreshing the configs
1657 */
1658 ctre::phoenix::StatusCode Refresh(MotorOutputConfigs &configs, units::time::second_t timeoutSeconds) const
1659 {
1660 std::string ref;
1661 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1662 configs.Deserialize(ref);
1663 return ret;
1664 }
1665
1666 /**
1667 * \brief Refreshes the values of the specified config group.
1668 *
1669 * This will wait up to #DefaultTimeoutSeconds.
1670 *
1671 * \details Call to refresh the selected configs from the device.
1672 *
1673 * \param configs The configs to refresh
1674 * \returns Status code of refreshing the configs
1675 */
1676 ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs &configs) const
1677 {
1678 return Refresh(configs, DefaultTimeoutSeconds);
1679 }
1680 /**
1681 * \brief Refreshes the values of the specified config group.
1682 *
1683 * \details Call to refresh the selected configs from the device.
1684 *
1685 * \param configs The configs to refresh
1686 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1687 * \returns Status code of refreshing the configs
1688 */
1689 ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs &configs, units::time::second_t timeoutSeconds) const
1690 {
1691 std::string ref;
1692 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1693 configs.Deserialize(ref);
1694 return ret;
1695 }
1696
1697 /**
1698 * \brief Refreshes the values of the specified config group.
1699 *
1700 * This will wait up to #DefaultTimeoutSeconds.
1701 *
1702 * \details Call to refresh the selected configs from the device.
1703 *
1704 * \param configs The configs to refresh
1705 * \returns Status code of refreshing the configs
1706 */
1707 ctre::phoenix::StatusCode Refresh(VoltageConfigs &configs) const
1708 {
1709 return Refresh(configs, DefaultTimeoutSeconds);
1710 }
1711 /**
1712 * \brief Refreshes the values of the specified config group.
1713 *
1714 * \details Call to refresh the selected configs from the device.
1715 *
1716 * \param configs The configs to refresh
1717 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1718 * \returns Status code of refreshing the configs
1719 */
1720 ctre::phoenix::StatusCode Refresh(VoltageConfigs &configs, units::time::second_t timeoutSeconds) const
1721 {
1722 std::string ref;
1723 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1724 configs.Deserialize(ref);
1725 return ret;
1726 }
1727
1728 /**
1729 * \brief Refreshes the values of the specified config group.
1730 *
1731 * This will wait up to #DefaultTimeoutSeconds.
1732 *
1733 * \details Call to refresh the selected configs from the device.
1734 *
1735 * \param configs The configs to refresh
1736 * \returns Status code of refreshing the configs
1737 */
1738 ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs &configs) const
1739 {
1740 return Refresh(configs, DefaultTimeoutSeconds);
1741 }
1742 /**
1743 * \brief Refreshes the values of the specified config group.
1744 *
1745 * \details Call to refresh the selected configs from the device.
1746 *
1747 * \param configs The configs to refresh
1748 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1749 * \returns Status code of refreshing the configs
1750 */
1751 ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs &configs, units::time::second_t timeoutSeconds) const
1752 {
1753 std::string ref;
1754 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1755 configs.Deserialize(ref);
1756 return ret;
1757 }
1758
1759 /**
1760 * \brief Refreshes the values of the specified config group.
1761 *
1762 * This will wait up to #DefaultTimeoutSeconds.
1763 *
1764 * \details Call to refresh the selected configs from the device.
1765 *
1766 * \param configs The configs to refresh
1767 * \returns Status code of refreshing the configs
1768 */
1769 ctre::phoenix::StatusCode Refresh(FeedbackConfigs &configs) const
1770 {
1771 return Refresh(configs, DefaultTimeoutSeconds);
1772 }
1773 /**
1774 * \brief Refreshes the values of the specified config group.
1775 *
1776 * \details Call to refresh the selected configs from the device.
1777 *
1778 * \param configs The configs to refresh
1779 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1780 * \returns Status code of refreshing the configs
1781 */
1782 ctre::phoenix::StatusCode Refresh(FeedbackConfigs &configs, units::time::second_t timeoutSeconds) const
1783 {
1784 std::string ref;
1785 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1786 configs.Deserialize(ref);
1787 return ret;
1788 }
1789
1790 /**
1791 * \brief Refreshes the values of the specified config group.
1792 *
1793 * This will wait up to #DefaultTimeoutSeconds.
1794 *
1795 * \details Call to refresh the selected configs from the device.
1796 *
1797 * \param configs The configs to refresh
1798 * \returns Status code of refreshing the configs
1799 */
1800 ctre::phoenix::StatusCode Refresh(DifferentialSensorsConfigs &configs) const
1801 {
1802 return Refresh(configs, DefaultTimeoutSeconds);
1803 }
1804 /**
1805 * \brief Refreshes the values of the specified config group.
1806 *
1807 * \details Call to refresh the selected configs from the device.
1808 *
1809 * \param configs The configs to refresh
1810 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1811 * \returns Status code of refreshing the configs
1812 */
1813 ctre::phoenix::StatusCode Refresh(DifferentialSensorsConfigs &configs, units::time::second_t timeoutSeconds) const
1814 {
1815 std::string ref;
1816 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1817 configs.Deserialize(ref);
1818 return ret;
1819 }
1820
1821 /**
1822 * \brief Refreshes the values of the specified config group.
1823 *
1824 * This will wait up to #DefaultTimeoutSeconds.
1825 *
1826 * \details Call to refresh the selected configs from the device.
1827 *
1828 * \param configs The configs to refresh
1829 * \returns Status code of refreshing the configs
1830 */
1831 ctre::phoenix::StatusCode Refresh(DifferentialConstantsConfigs &configs) const
1832 {
1833 return Refresh(configs, DefaultTimeoutSeconds);
1834 }
1835 /**
1836 * \brief Refreshes the values of the specified config group.
1837 *
1838 * \details Call to refresh the selected configs from the device.
1839 *
1840 * \param configs The configs to refresh
1841 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1842 * \returns Status code of refreshing the configs
1843 */
1844 ctre::phoenix::StatusCode Refresh(DifferentialConstantsConfigs &configs, units::time::second_t timeoutSeconds) const
1845 {
1846 std::string ref;
1847 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1848 configs.Deserialize(ref);
1849 return ret;
1850 }
1851
1852 /**
1853 * \brief Refreshes the values of the specified config group.
1854 *
1855 * This will wait up to #DefaultTimeoutSeconds.
1856 *
1857 * \details Call to refresh the selected configs from the device.
1858 *
1859 * \param configs The configs to refresh
1860 * \returns Status code of refreshing the configs
1861 */
1862 ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs &configs) const
1863 {
1864 return Refresh(configs, DefaultTimeoutSeconds);
1865 }
1866 /**
1867 * \brief Refreshes the values of the specified config group.
1868 *
1869 * \details Call to refresh the selected configs from the device.
1870 *
1871 * \param configs The configs to refresh
1872 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1873 * \returns Status code of refreshing the configs
1874 */
1875 ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs &configs, units::time::second_t timeoutSeconds) const
1876 {
1877 std::string ref;
1878 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1879 configs.Deserialize(ref);
1880 return ret;
1881 }
1882
1883 /**
1884 * \brief Refreshes the values of the specified config group.
1885 *
1886 * This will wait up to #DefaultTimeoutSeconds.
1887 *
1888 * \details Call to refresh the selected configs from the device.
1889 *
1890 * \param configs The configs to refresh
1891 * \returns Status code of refreshing the configs
1892 */
1893 ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs &configs) const
1894 {
1895 return Refresh(configs, DefaultTimeoutSeconds);
1896 }
1897 /**
1898 * \brief Refreshes the values of the specified config group.
1899 *
1900 * \details Call to refresh the selected configs from the device.
1901 *
1902 * \param configs The configs to refresh
1903 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1904 * \returns Status code of refreshing the configs
1905 */
1906 ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs &configs, units::time::second_t timeoutSeconds) const
1907 {
1908 std::string ref;
1909 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1910 configs.Deserialize(ref);
1911 return ret;
1912 }
1913
1914 /**
1915 * \brief Refreshes the values of the specified config group.
1916 *
1917 * This will wait up to #DefaultTimeoutSeconds.
1918 *
1919 * \details Call to refresh the selected configs from the device.
1920 *
1921 * \param configs The configs to refresh
1922 * \returns Status code of refreshing the configs
1923 */
1924 ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs &configs) const
1925 {
1926 return Refresh(configs, DefaultTimeoutSeconds);
1927 }
1928 /**
1929 * \brief Refreshes the values of the specified config group.
1930 *
1931 * \details Call to refresh the selected configs from the device.
1932 *
1933 * \param configs The configs to refresh
1934 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1935 * \returns Status code of refreshing the configs
1936 */
1937 ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds) const
1938 {
1939 std::string ref;
1940 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1941 configs.Deserialize(ref);
1942 return ret;
1943 }
1944
1945 /**
1946 * \brief Refreshes the values of the specified config group.
1947 *
1948 * This will wait up to #DefaultTimeoutSeconds.
1949 *
1950 * \details Call to refresh the selected configs from the device.
1951 *
1952 * \param configs The configs to refresh
1953 * \returns Status code of refreshing the configs
1954 */
1955 ctre::phoenix::StatusCode Refresh(AudioConfigs &configs) const
1956 {
1957 return Refresh(configs, DefaultTimeoutSeconds);
1958 }
1959 /**
1960 * \brief Refreshes the values of the specified config group.
1961 *
1962 * \details Call to refresh the selected configs from the device.
1963 *
1964 * \param configs The configs to refresh
1965 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1966 * \returns Status code of refreshing the configs
1967 */
1968 ctre::phoenix::StatusCode Refresh(AudioConfigs &configs, units::time::second_t timeoutSeconds) const
1969 {
1970 std::string ref;
1971 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
1972 configs.Deserialize(ref);
1973 return ret;
1974 }
1975
1976 /**
1977 * \brief Refreshes the values of the specified config group.
1978 *
1979 * This will wait up to #DefaultTimeoutSeconds.
1980 *
1981 * \details Call to refresh the selected configs from the device.
1982 *
1983 * \param configs The configs to refresh
1984 * \returns Status code of refreshing the configs
1985 */
1986 ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs &configs) const
1987 {
1988 return Refresh(configs, DefaultTimeoutSeconds);
1989 }
1990 /**
1991 * \brief Refreshes the values of the specified config group.
1992 *
1993 * \details Call to refresh the selected configs from the device.
1994 *
1995 * \param configs The configs to refresh
1996 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
1997 * \returns Status code of refreshing the configs
1998 */
1999 ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds) const
2000 {
2001 std::string ref;
2002 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2003 configs.Deserialize(ref);
2004 return ret;
2005 }
2006
2007 /**
2008 * \brief Refreshes the values of the specified config group.
2009 *
2010 * This will wait up to #DefaultTimeoutSeconds.
2011 *
2012 * \details Call to refresh the selected configs from the device.
2013 *
2014 * \param configs The configs to refresh
2015 * \returns Status code of refreshing the configs
2016 */
2017 ctre::phoenix::StatusCode Refresh(MotionMagicConfigs &configs) const
2018 {
2019 return Refresh(configs, DefaultTimeoutSeconds);
2020 }
2021 /**
2022 * \brief Refreshes the values of the specified config group.
2023 *
2024 * \details Call to refresh the selected configs from the device.
2025 *
2026 * \param configs The configs to refresh
2027 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2028 * \returns Status code of refreshing the configs
2029 */
2030 ctre::phoenix::StatusCode Refresh(MotionMagicConfigs &configs, units::time::second_t timeoutSeconds) const
2031 {
2032 std::string ref;
2033 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2034 configs.Deserialize(ref);
2035 return ret;
2036 }
2037
2038 /**
2039 * \brief Refreshes the values of the specified config group.
2040 *
2041 * This will wait up to #DefaultTimeoutSeconds.
2042 *
2043 * \details Call to refresh the selected configs from the device.
2044 *
2045 * \param configs The configs to refresh
2046 * \returns Status code of refreshing the configs
2047 */
2048 ctre::phoenix::StatusCode Refresh(CustomParamsConfigs &configs) const
2049 {
2050 return Refresh(configs, DefaultTimeoutSeconds);
2051 }
2052 /**
2053 * \brief Refreshes the values of the specified config group.
2054 *
2055 * \details Call to refresh the selected configs from the device.
2056 *
2057 * \param configs The configs to refresh
2058 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2059 * \returns Status code of refreshing the configs
2060 */
2061 ctre::phoenix::StatusCode Refresh(CustomParamsConfigs &configs, units::time::second_t timeoutSeconds) const
2062 {
2063 std::string ref;
2064 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2065 configs.Deserialize(ref);
2066 return ret;
2067 }
2068
2069 /**
2070 * \brief Refreshes the values of the specified config group.
2071 *
2072 * This will wait up to #DefaultTimeoutSeconds.
2073 *
2074 * \details Call to refresh the selected configs from the device.
2075 *
2076 * \param configs The configs to refresh
2077 * \returns Status code of refreshing the configs
2078 */
2079 ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs &configs) const
2080 {
2081 return Refresh(configs, DefaultTimeoutSeconds);
2082 }
2083 /**
2084 * \brief Refreshes the values of the specified config group.
2085 *
2086 * \details Call to refresh the selected configs from the device.
2087 *
2088 * \param configs The configs to refresh
2089 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2090 * \returns Status code of refreshing the configs
2091 */
2092 ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs &configs, units::time::second_t timeoutSeconds) const
2093 {
2094 std::string ref;
2095 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2096 configs.Deserialize(ref);
2097 return ret;
2098 }
2099
2100 /**
2101 * \brief Refreshes the values of the specified config group.
2102 *
2103 * This will wait up to #DefaultTimeoutSeconds.
2104 *
2105 * \details Call to refresh the selected configs from the device.
2106 *
2107 * \param configs The configs to refresh
2108 * \returns Status code of refreshing the configs
2109 */
2110 ctre::phoenix::StatusCode Refresh(Slot0Configs &configs) const
2111 {
2112 return Refresh(configs, DefaultTimeoutSeconds);
2113 }
2114 /**
2115 * \brief Refreshes the values of the specified config group.
2116 *
2117 * \details Call to refresh the selected configs from the device.
2118 *
2119 * \param configs The configs to refresh
2120 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2121 * \returns Status code of refreshing the configs
2122 */
2123 ctre::phoenix::StatusCode Refresh(Slot0Configs &configs, units::time::second_t timeoutSeconds) const
2124 {
2125 std::string ref;
2126 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2127 configs.Deserialize(ref);
2128 return ret;
2129 }
2130
2131 /**
2132 * \brief Refreshes the values of the specified config group.
2133 *
2134 * This will wait up to #DefaultTimeoutSeconds.
2135 *
2136 * \details Call to refresh the selected configs from the device.
2137 *
2138 * \param configs The configs to refresh
2139 * \returns Status code of refreshing the configs
2140 */
2141 ctre::phoenix::StatusCode Refresh(Slot1Configs &configs) const
2142 {
2143 return Refresh(configs, DefaultTimeoutSeconds);
2144 }
2145 /**
2146 * \brief Refreshes the values of the specified config group.
2147 *
2148 * \details Call to refresh the selected configs from the device.
2149 *
2150 * \param configs The configs to refresh
2151 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2152 * \returns Status code of refreshing the configs
2153 */
2154 ctre::phoenix::StatusCode Refresh(Slot1Configs &configs, units::time::second_t timeoutSeconds) const
2155 {
2156 std::string ref;
2157 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2158 configs.Deserialize(ref);
2159 return ret;
2160 }
2161
2162 /**
2163 * \brief Refreshes the values of the specified config group.
2164 *
2165 * This will wait up to #DefaultTimeoutSeconds.
2166 *
2167 * \details Call to refresh the selected configs from the device.
2168 *
2169 * \param configs The configs to refresh
2170 * \returns Status code of refreshing the configs
2171 */
2172 ctre::phoenix::StatusCode Refresh(Slot2Configs &configs) const
2173 {
2174 return Refresh(configs, DefaultTimeoutSeconds);
2175 }
2176 /**
2177 * \brief Refreshes the values of the specified config group.
2178 *
2179 * \details Call to refresh the selected configs from the device.
2180 *
2181 * \param configs The configs to refresh
2182 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2183 * \returns Status code of refreshing the configs
2184 */
2185 ctre::phoenix::StatusCode Refresh(Slot2Configs &configs, units::time::second_t timeoutSeconds) const
2186 {
2187 std::string ref;
2188 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2189 configs.Deserialize(ref);
2190 return ret;
2191 }
2192
2193 /**
2194 * \brief Refreshes the values of the specified config group.
2195 *
2196 * This will wait up to #DefaultTimeoutSeconds.
2197 *
2198 * \details Call to refresh the selected configs from the device.
2199 *
2200 * \param configs The configs to refresh
2201 * \returns Status code of refreshing the configs
2202 */
2203 ctre::phoenix::StatusCode Refresh(SlotConfigs &configs) const
2204 {
2205 return Refresh(configs, DefaultTimeoutSeconds);
2206 }
2207 /**
2208 * \brief Refreshes the values of the specified config group.
2209 *
2210 * \details Call to refresh the selected configs from the device.
2211 *
2212 * \param configs The configs to refresh
2213 * \param timeoutSeconds Maximum amount of time to wait when performing configuration
2214 * \returns Status code of refreshing the configs
2215 */
2216 ctre::phoenix::StatusCode Refresh(SlotConfigs &configs, units::time::second_t timeoutSeconds) const
2217 {
2218 std::string ref;
2219 ctre::phoenix::StatusCode ret = GetConfigsPrivate(ref, timeoutSeconds);
2220 configs.Deserialize(ref);
2221 return ret;
2222 }
2223
2224
2225 /**
2226 * \brief Sets the mechanism position of the device in mechanism
2227 * rotations.
2228 *
2229 * This will wait up to #DefaultTimeoutSeconds.
2230 *
2231 * This is available in the configurator in case the user wants
2232 * to initialize their device entirely without passing a device
2233 * reference down to the code that performs the initialization.
2234 * In this case, the user passes down the configurator object
2235 * and performs all the initialization code on the object.
2236 *
2237 * \param newValue Value to set to. Units are in rotations.
2238 * \returns StatusCode of the set command
2239 */
2240 ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue)
2241 {
2242 return SetPosition(newValue, DefaultTimeoutSeconds);
2243 }
2244 /**
2245 * \brief Sets the mechanism position of the device in mechanism
2246 * rotations.
2247 *
2248 * This is available in the configurator in case the user wants
2249 * to initialize their device entirely without passing a device
2250 * reference down to the code that performs the initialization.
2251 * In this case, the user passes down the configurator object
2252 * and performs all the initialization code on the object.
2253 *
2254 * \param newValue Value to set to. Units are in rotations.
2255 * \param timeoutSeconds Maximum time to wait up to in seconds.
2256 * \returns StatusCode of the set command
2257 */
2258 ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue, units::time::second_t timeoutSeconds);
2259
2260 /**
2261 * \brief Clear the sticky faults in the device.
2262 *
2263 * \details This typically has no impact on the device functionality.
2264 * Instead, it just clears telemetry faults that are accessible via
2265 * API and Tuner Self-Test.
2266 *
2267 * This will wait up to #DefaultTimeoutSeconds.
2268 *
2269 * This is available in the configurator in case the user wants
2270 * to initialize their device entirely without passing a device
2271 * reference down to the code that performs the initialization.
2272 * In this case, the user passes down the configurator object
2273 * and performs all the initialization code on the object.
2274 *
2275 * \returns StatusCode of the set command
2276 */
2277 ctre::phoenix::StatusCode ClearStickyFaults()
2278 {
2279 return ClearStickyFaults(DefaultTimeoutSeconds);
2280 }
2281 /**
2282 * \brief Clear the sticky faults in the device.
2283 *
2284 * \details This typically has no impact on the device functionality.
2285 * Instead, it just clears telemetry faults that are accessible via
2286 * API and Tuner Self-Test.
2287 *
2288 * This is available in the configurator in case the user wants
2289 * to initialize their device entirely without passing a device
2290 * reference down to the code that performs the initialization.
2291 * In this case, the user passes down the configurator object
2292 * and performs all the initialization code on the object.
2293 *
2294 * \param timeoutSeconds Maximum time to wait up to in seconds.
2295 * \returns StatusCode of the set command
2296 */
2297 ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds);
2298
2299 /**
2300 * \brief Clear sticky fault: Hardware fault occurred
2301 *
2302 * This will wait up to #DefaultTimeoutSeconds.
2303 *
2304 * This is available in the configurator in case the user wants
2305 * to initialize their device entirely without passing a device
2306 * reference down to the code that performs the initialization.
2307 * In this case, the user passes down the configurator object
2308 * and performs all the initialization code on the object.
2309 *
2310 * \returns StatusCode of the set command
2311 */
2312 ctre::phoenix::StatusCode ClearStickyFault_Hardware()
2313 {
2314 return ClearStickyFault_Hardware(DefaultTimeoutSeconds);
2315 }
2316 /**
2317 * \brief Clear sticky fault: Hardware fault occurred
2318 *
2319 * This is available in the configurator in case the user wants
2320 * to initialize their device entirely without passing a device
2321 * reference down to the code that performs the initialization.
2322 * In this case, the user passes down the configurator object
2323 * and performs all the initialization code on the object.
2324 *
2325 * \param timeoutSeconds Maximum time to wait up to in seconds.
2326 * \returns StatusCode of the set command
2327 */
2328 ctre::phoenix::StatusCode ClearStickyFault_Hardware(units::time::second_t timeoutSeconds);
2329
2330 /**
2331 * \brief Clear sticky fault: Processor temperature exceeded limit
2332 *
2333 * This will wait up to #DefaultTimeoutSeconds.
2334 *
2335 * This is available in the configurator in case the user wants
2336 * to initialize their device entirely without passing a device
2337 * reference down to the code that performs the initialization.
2338 * In this case, the user passes down the configurator object
2339 * and performs all the initialization code on the object.
2340 *
2341 * \returns StatusCode of the set command
2342 */
2343 ctre::phoenix::StatusCode ClearStickyFault_ProcTemp()
2344 {
2345 return ClearStickyFault_ProcTemp(DefaultTimeoutSeconds);
2346 }
2347 /**
2348 * \brief Clear sticky fault: Processor temperature exceeded limit
2349 *
2350 * This is available in the configurator in case the user wants
2351 * to initialize their device entirely without passing a device
2352 * reference down to the code that performs the initialization.
2353 * In this case, the user passes down the configurator object
2354 * and performs all the initialization code on the object.
2355 *
2356 * \param timeoutSeconds Maximum time to wait up to in seconds.
2357 * \returns StatusCode of the set command
2358 */
2359 ctre::phoenix::StatusCode ClearStickyFault_ProcTemp(units::time::second_t timeoutSeconds);
2360
2361 /**
2362 * \brief Clear sticky fault: Device temperature exceeded limit
2363 *
2364 * This will wait up to #DefaultTimeoutSeconds.
2365 *
2366 * This is available in the configurator in case the user wants
2367 * to initialize their device entirely without passing a device
2368 * reference down to the code that performs the initialization.
2369 * In this case, the user passes down the configurator object
2370 * and performs all the initialization code on the object.
2371 *
2372 * \returns StatusCode of the set command
2373 */
2374 ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp()
2375 {
2376 return ClearStickyFault_DeviceTemp(DefaultTimeoutSeconds);
2377 }
2378 /**
2379 * \brief Clear sticky fault: Device temperature exceeded limit
2380 *
2381 * This is available in the configurator in case the user wants
2382 * to initialize their device entirely without passing a device
2383 * reference down to the code that performs the initialization.
2384 * In this case, the user passes down the configurator object
2385 * and performs all the initialization code on the object.
2386 *
2387 * \param timeoutSeconds Maximum time to wait up to in seconds.
2388 * \returns StatusCode of the set command
2389 */
2390 ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp(units::time::second_t timeoutSeconds);
2391
2392 /**
2393 * \brief Clear sticky fault: Device supply voltage dropped to near
2394 * brownout levels
2395 *
2396 * This will wait up to #DefaultTimeoutSeconds.
2397 *
2398 * This is available in the configurator in case the user wants
2399 * to initialize their device entirely without passing a device
2400 * reference down to the code that performs the initialization.
2401 * In this case, the user passes down the configurator object
2402 * and performs all the initialization code on the object.
2403 *
2404 * \returns StatusCode of the set command
2405 */
2406 ctre::phoenix::StatusCode ClearStickyFault_Undervoltage()
2407 {
2408 return ClearStickyFault_Undervoltage(DefaultTimeoutSeconds);
2409 }
2410 /**
2411 * \brief Clear sticky fault: Device supply voltage dropped to near
2412 * brownout levels
2413 *
2414 * This is available in the configurator in case the user wants
2415 * to initialize their device entirely without passing a device
2416 * reference down to the code that performs the initialization.
2417 * In this case, the user passes down the configurator object
2418 * and performs all the initialization code on the object.
2419 *
2420 * \param timeoutSeconds Maximum time to wait up to in seconds.
2421 * \returns StatusCode of the set command
2422 */
2423 ctre::phoenix::StatusCode ClearStickyFault_Undervoltage(units::time::second_t timeoutSeconds);
2424
2425 /**
2426 * \brief Clear sticky fault: Device boot while detecting the enable
2427 * signal
2428 *
2429 * This will wait up to #DefaultTimeoutSeconds.
2430 *
2431 * This is available in the configurator in case the user wants
2432 * to initialize their device entirely without passing a device
2433 * reference down to the code that performs the initialization.
2434 * In this case, the user passes down the configurator object
2435 * and performs all the initialization code on the object.
2436 *
2437 * \returns StatusCode of the set command
2438 */
2439 ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable()
2440 {
2441 return ClearStickyFault_BootDuringEnable(DefaultTimeoutSeconds);
2442 }
2443 /**
2444 * \brief Clear sticky fault: Device boot while detecting the enable
2445 * signal
2446 *
2447 * This is available in the configurator in case the user wants
2448 * to initialize their device entirely without passing a device
2449 * reference down to the code that performs the initialization.
2450 * In this case, the user passes down the configurator object
2451 * and performs all the initialization code on the object.
2452 *
2453 * \param timeoutSeconds Maximum time to wait up to in seconds.
2454 * \returns StatusCode of the set command
2455 */
2456 ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable(units::time::second_t timeoutSeconds);
2457
2458 /**
2459 * \brief Clear sticky fault: An unlicensed feature is in use, device
2460 * may not behave as expected.
2461 *
2462 * This will wait up to #DefaultTimeoutSeconds.
2463 *
2464 * This is available in the configurator in case the user wants
2465 * to initialize their device entirely without passing a device
2466 * reference down to the code that performs the initialization.
2467 * In this case, the user passes down the configurator object
2468 * and performs all the initialization code on the object.
2469 *
2470 * \returns StatusCode of the set command
2471 */
2472 ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse()
2473 {
2474 return ClearStickyFault_UnlicensedFeatureInUse(DefaultTimeoutSeconds);
2475 }
2476 /**
2477 * \brief Clear sticky fault: An unlicensed feature is in use, device
2478 * may not behave as expected.
2479 *
2480 * This is available in the configurator in case the user wants
2481 * to initialize their device entirely without passing a device
2482 * reference down to the code that performs the initialization.
2483 * In this case, the user passes down the configurator object
2484 * and performs all the initialization code on the object.
2485 *
2486 * \param timeoutSeconds Maximum time to wait up to in seconds.
2487 * \returns StatusCode of the set command
2488 */
2489 ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse(units::time::second_t timeoutSeconds);
2490
2491 /**
2492 * \brief Clear sticky fault: Bridge was disabled most likely due to
2493 * supply voltage dropping too low.
2494 *
2495 * This will wait up to #DefaultTimeoutSeconds.
2496 *
2497 * This is available in the configurator in case the user wants
2498 * to initialize their device entirely without passing a device
2499 * reference down to the code that performs the initialization.
2500 * In this case, the user passes down the configurator object
2501 * and performs all the initialization code on the object.
2502 *
2503 * \returns StatusCode of the set command
2504 */
2505 ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout()
2506 {
2507 return ClearStickyFault_BridgeBrownout(DefaultTimeoutSeconds);
2508 }
2509 /**
2510 * \brief Clear sticky fault: Bridge was disabled most likely due to
2511 * supply voltage dropping too low.
2512 *
2513 * This is available in the configurator in case the user wants
2514 * to initialize their device entirely without passing a device
2515 * reference down to the code that performs the initialization.
2516 * In this case, the user passes down the configurator object
2517 * and performs all the initialization code on the object.
2518 *
2519 * \param timeoutSeconds Maximum time to wait up to in seconds.
2520 * \returns StatusCode of the set command
2521 */
2522 ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout(units::time::second_t timeoutSeconds);
2523
2524 /**
2525 * \brief Clear sticky fault: The remote sensor has reset.
2526 *
2527 * This will wait up to #DefaultTimeoutSeconds.
2528 *
2529 * This is available in the configurator in case the user wants
2530 * to initialize their device entirely without passing a device
2531 * reference down to the code that performs the initialization.
2532 * In this case, the user passes down the configurator object
2533 * and performs all the initialization code on the object.
2534 *
2535 * \returns StatusCode of the set command
2536 */
2537 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset()
2538 {
2539 return ClearStickyFault_RemoteSensorReset(DefaultTimeoutSeconds);
2540 }
2541 /**
2542 * \brief Clear sticky fault: The remote sensor has reset.
2543 *
2544 * This is available in the configurator in case the user wants
2545 * to initialize their device entirely without passing a device
2546 * reference down to the code that performs the initialization.
2547 * In this case, the user passes down the configurator object
2548 * and performs all the initialization code on the object.
2549 *
2550 * \param timeoutSeconds Maximum time to wait up to in seconds.
2551 * \returns StatusCode of the set command
2552 */
2553 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset(units::time::second_t timeoutSeconds);
2554
2555 /**
2556 * \brief Clear sticky fault: The remote Talon used for differential
2557 * control is not present on CAN Bus.
2558 *
2559 * This will wait up to #DefaultTimeoutSeconds.
2560 *
2561 * This is available in the configurator in case the user wants
2562 * to initialize their device entirely without passing a device
2563 * reference down to the code that performs the initialization.
2564 * In this case, the user passes down the configurator object
2565 * and performs all the initialization code on the object.
2566 *
2567 * \returns StatusCode of the set command
2568 */
2569 ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX()
2570 {
2571 return ClearStickyFault_MissingDifferentialFX(DefaultTimeoutSeconds);
2572 }
2573 /**
2574 * \brief Clear sticky fault: The remote Talon used for differential
2575 * control is not present on CAN Bus.
2576 *
2577 * This is available in the configurator in case the user wants
2578 * to initialize their device entirely without passing a device
2579 * reference down to the code that performs the initialization.
2580 * In this case, the user passes down the configurator object
2581 * and performs all the initialization code on the object.
2582 *
2583 * \param timeoutSeconds Maximum time to wait up to in seconds.
2584 * \returns StatusCode of the set command
2585 */
2586 ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX(units::time::second_t timeoutSeconds);
2587
2588 /**
2589 * \brief Clear sticky fault: The remote sensor position has
2590 * overflowed. Because of the nature of remote sensors, it is possible
2591 * for the remote sensor position to overflow beyond what is supported
2592 * by the status signal frame. However, this is rare and cannot occur
2593 * over the course of an FRC match under normal use.
2594 *
2595 * This will wait up to #DefaultTimeoutSeconds.
2596 *
2597 * This is available in the configurator in case the user wants
2598 * to initialize their device entirely without passing a device
2599 * reference down to the code that performs the initialization.
2600 * In this case, the user passes down the configurator object
2601 * and performs all the initialization code on the object.
2602 *
2603 * \returns StatusCode of the set command
2604 */
2605 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow()
2606 {
2607 return ClearStickyFault_RemoteSensorPosOverflow(DefaultTimeoutSeconds);
2608 }
2609 /**
2610 * \brief Clear sticky fault: The remote sensor position has
2611 * overflowed. Because of the nature of remote sensors, it is possible
2612 * for the remote sensor position to overflow beyond what is supported
2613 * by the status signal frame. However, this is rare and cannot occur
2614 * over the course of an FRC match under normal use.
2615 *
2616 * This is available in the configurator in case the user wants
2617 * to initialize their device entirely without passing a device
2618 * reference down to the code that performs the initialization.
2619 * In this case, the user passes down the configurator object
2620 * and performs all the initialization code on the object.
2621 *
2622 * \param timeoutSeconds Maximum time to wait up to in seconds.
2623 * \returns StatusCode of the set command
2624 */
2625 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow(units::time::second_t timeoutSeconds);
2626
2627 /**
2628 * \brief Clear sticky fault: Supply Voltage has exceeded the maximum
2629 * voltage rating of device.
2630 *
2631 * This will wait up to #DefaultTimeoutSeconds.
2632 *
2633 * This is available in the configurator in case the user wants
2634 * to initialize their device entirely without passing a device
2635 * reference down to the code that performs the initialization.
2636 * In this case, the user passes down the configurator object
2637 * and performs all the initialization code on the object.
2638 *
2639 * \returns StatusCode of the set command
2640 */
2641 ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV()
2642 {
2643 return ClearStickyFault_OverSupplyV(DefaultTimeoutSeconds);
2644 }
2645 /**
2646 * \brief Clear sticky fault: Supply Voltage has exceeded the maximum
2647 * voltage rating of device.
2648 *
2649 * This is available in the configurator in case the user wants
2650 * to initialize their device entirely without passing a device
2651 * reference down to the code that performs the initialization.
2652 * In this case, the user passes down the configurator object
2653 * and performs all the initialization code on the object.
2654 *
2655 * \param timeoutSeconds Maximum time to wait up to in seconds.
2656 * \returns StatusCode of the set command
2657 */
2658 ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV(units::time::second_t timeoutSeconds);
2659
2660 /**
2661 * \brief Clear sticky fault: Supply Voltage is unstable. Ensure you
2662 * are using a battery and current limited power supply.
2663 *
2664 * This will wait up to #DefaultTimeoutSeconds.
2665 *
2666 * This is available in the configurator in case the user wants
2667 * to initialize their device entirely without passing a device
2668 * reference down to the code that performs the initialization.
2669 * In this case, the user passes down the configurator object
2670 * and performs all the initialization code on the object.
2671 *
2672 * \returns StatusCode of the set command
2673 */
2674 ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV()
2675 {
2676 return ClearStickyFault_UnstableSupplyV(DefaultTimeoutSeconds);
2677 }
2678 /**
2679 * \brief Clear sticky fault: Supply Voltage is unstable. Ensure you
2680 * are using a battery and current limited power supply.
2681 *
2682 * This is available in the configurator in case the user wants
2683 * to initialize their device entirely without passing a device
2684 * reference down to the code that performs the initialization.
2685 * In this case, the user passes down the configurator object
2686 * and performs all the initialization code on the object.
2687 *
2688 * \param timeoutSeconds Maximum time to wait up to in seconds.
2689 * \returns StatusCode of the set command
2690 */
2691 ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV(units::time::second_t timeoutSeconds);
2692
2693 /**
2694 * \brief Clear sticky fault: Reverse limit switch has been asserted.
2695 * Output is set to neutral.
2696 *
2697 * This will wait up to #DefaultTimeoutSeconds.
2698 *
2699 * This is available in the configurator in case the user wants
2700 * to initialize their device entirely without passing a device
2701 * reference down to the code that performs the initialization.
2702 * In this case, the user passes down the configurator object
2703 * and performs all the initialization code on the object.
2704 *
2705 * \returns StatusCode of the set command
2706 */
2707 ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit()
2708 {
2709 return ClearStickyFault_ReverseHardLimit(DefaultTimeoutSeconds);
2710 }
2711 /**
2712 * \brief Clear sticky fault: Reverse limit switch has been asserted.
2713 * Output is set to neutral.
2714 *
2715 * This is available in the configurator in case the user wants
2716 * to initialize their device entirely without passing a device
2717 * reference down to the code that performs the initialization.
2718 * In this case, the user passes down the configurator object
2719 * and performs all the initialization code on the object.
2720 *
2721 * \param timeoutSeconds Maximum time to wait up to in seconds.
2722 * \returns StatusCode of the set command
2723 */
2724 ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit(units::time::second_t timeoutSeconds);
2725
2726 /**
2727 * \brief Clear sticky fault: Forward limit switch has been asserted.
2728 * Output is set to neutral.
2729 *
2730 * This will wait up to #DefaultTimeoutSeconds.
2731 *
2732 * This is available in the configurator in case the user wants
2733 * to initialize their device entirely without passing a device
2734 * reference down to the code that performs the initialization.
2735 * In this case, the user passes down the configurator object
2736 * and performs all the initialization code on the object.
2737 *
2738 * \returns StatusCode of the set command
2739 */
2740 ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit()
2741 {
2742 return ClearStickyFault_ForwardHardLimit(DefaultTimeoutSeconds);
2743 }
2744 /**
2745 * \brief Clear sticky fault: Forward limit switch has been asserted.
2746 * Output is set to neutral.
2747 *
2748 * This is available in the configurator in case the user wants
2749 * to initialize their device entirely without passing a device
2750 * reference down to the code that performs the initialization.
2751 * In this case, the user passes down the configurator object
2752 * and performs all the initialization code on the object.
2753 *
2754 * \param timeoutSeconds Maximum time to wait up to in seconds.
2755 * \returns StatusCode of the set command
2756 */
2757 ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit(units::time::second_t timeoutSeconds);
2758
2759 /**
2760 * \brief Clear sticky fault: Reverse soft limit has been asserted.
2761 * Output is set to neutral.
2762 *
2763 * This will wait up to #DefaultTimeoutSeconds.
2764 *
2765 * This is available in the configurator in case the user wants
2766 * to initialize their device entirely without passing a device
2767 * reference down to the code that performs the initialization.
2768 * In this case, the user passes down the configurator object
2769 * and performs all the initialization code on the object.
2770 *
2771 * \returns StatusCode of the set command
2772 */
2773 ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit()
2774 {
2775 return ClearStickyFault_ReverseSoftLimit(DefaultTimeoutSeconds);
2776 }
2777 /**
2778 * \brief Clear sticky fault: Reverse soft limit has been asserted.
2779 * Output is set to neutral.
2780 *
2781 * This is available in the configurator in case the user wants
2782 * to initialize their device entirely without passing a device
2783 * reference down to the code that performs the initialization.
2784 * In this case, the user passes down the configurator object
2785 * and performs all the initialization code on the object.
2786 *
2787 * \param timeoutSeconds Maximum time to wait up to in seconds.
2788 * \returns StatusCode of the set command
2789 */
2790 ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit(units::time::second_t timeoutSeconds);
2791
2792 /**
2793 * \brief Clear sticky fault: Forward soft limit has been asserted.
2794 * Output is set to neutral.
2795 *
2796 * This will wait up to #DefaultTimeoutSeconds.
2797 *
2798 * This is available in the configurator in case the user wants
2799 * to initialize their device entirely without passing a device
2800 * reference down to the code that performs the initialization.
2801 * In this case, the user passes down the configurator object
2802 * and performs all the initialization code on the object.
2803 *
2804 * \returns StatusCode of the set command
2805 */
2806 ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit()
2807 {
2808 return ClearStickyFault_ForwardSoftLimit(DefaultTimeoutSeconds);
2809 }
2810 /**
2811 * \brief Clear sticky fault: Forward soft limit has been asserted.
2812 * Output is set to neutral.
2813 *
2814 * This is available in the configurator in case the user wants
2815 * to initialize their device entirely without passing a device
2816 * reference down to the code that performs the initialization.
2817 * In this case, the user passes down the configurator object
2818 * and performs all the initialization code on the object.
2819 *
2820 * \param timeoutSeconds Maximum time to wait up to in seconds.
2821 * \returns StatusCode of the set command
2822 */
2823 ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit(units::time::second_t timeoutSeconds);
2824
2825 /**
2826 * \brief Clear sticky fault: The remote soft limit device is not
2827 * present on CAN Bus.
2828 *
2829 * This will wait up to #DefaultTimeoutSeconds.
2830 *
2831 * This is available in the configurator in case the user wants
2832 * to initialize their device entirely without passing a device
2833 * reference down to the code that performs the initialization.
2834 * In this case, the user passes down the configurator object
2835 * and performs all the initialization code on the object.
2836 *
2837 * \returns StatusCode of the set command
2838 */
2839 ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote()
2840 {
2841 return ClearStickyFault_MissingSoftLimitRemote(DefaultTimeoutSeconds);
2842 }
2843 /**
2844 * \brief Clear sticky fault: The remote soft limit device is not
2845 * present on CAN Bus.
2846 *
2847 * This is available in the configurator in case the user wants
2848 * to initialize their device entirely without passing a device
2849 * reference down to the code that performs the initialization.
2850 * In this case, the user passes down the configurator object
2851 * and performs all the initialization code on the object.
2852 *
2853 * \param timeoutSeconds Maximum time to wait up to in seconds.
2854 * \returns StatusCode of the set command
2855 */
2856 ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote(units::time::second_t timeoutSeconds);
2857
2858 /**
2859 * \brief Clear sticky fault: The remote limit switch device is not
2860 * present on CAN Bus.
2861 *
2862 * This will wait up to #DefaultTimeoutSeconds.
2863 *
2864 * This is available in the configurator in case the user wants
2865 * to initialize their device entirely without passing a device
2866 * reference down to the code that performs the initialization.
2867 * In this case, the user passes down the configurator object
2868 * and performs all the initialization code on the object.
2869 *
2870 * \returns StatusCode of the set command
2871 */
2872 ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote()
2873 {
2874 return ClearStickyFault_MissingHardLimitRemote(DefaultTimeoutSeconds);
2875 }
2876 /**
2877 * \brief Clear sticky fault: The remote limit switch device is not
2878 * present on CAN Bus.
2879 *
2880 * This is available in the configurator in case the user wants
2881 * to initialize their device entirely without passing a device
2882 * reference down to the code that performs the initialization.
2883 * In this case, the user passes down the configurator object
2884 * and performs all the initialization code on the object.
2885 *
2886 * \param timeoutSeconds Maximum time to wait up to in seconds.
2887 * \returns StatusCode of the set command
2888 */
2889 ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote(units::time::second_t timeoutSeconds);
2890
2891 /**
2892 * \brief Clear sticky fault: The remote sensor's data is no longer
2893 * trusted. This can happen if the remote sensor disappears from the
2894 * CAN bus or if the remote sensor indicates its data is no longer
2895 * valid, such as when a CANcoder's magnet strength falls into the
2896 * "red" range.
2897 *
2898 * This will wait up to #DefaultTimeoutSeconds.
2899 *
2900 * This is available in the configurator in case the user wants
2901 * to initialize their device entirely without passing a device
2902 * reference down to the code that performs the initialization.
2903 * In this case, the user passes down the configurator object
2904 * and performs all the initialization code on the object.
2905 *
2906 * \returns StatusCode of the set command
2907 */
2908 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid()
2909 {
2910 return ClearStickyFault_RemoteSensorDataInvalid(DefaultTimeoutSeconds);
2911 }
2912 /**
2913 * \brief Clear sticky fault: The remote sensor's data is no longer
2914 * trusted. This can happen if the remote sensor disappears from the
2915 * CAN bus or if the remote sensor indicates its data is no longer
2916 * valid, such as when a CANcoder's magnet strength falls into the
2917 * "red" range.
2918 *
2919 * This is available in the configurator in case the user wants
2920 * to initialize their device entirely without passing a device
2921 * reference down to the code that performs the initialization.
2922 * In this case, the user passes down the configurator object
2923 * and performs all the initialization code on the object.
2924 *
2925 * \param timeoutSeconds Maximum time to wait up to in seconds.
2926 * \returns StatusCode of the set command
2927 */
2928 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid(units::time::second_t timeoutSeconds);
2929
2930 /**
2931 * \brief Clear sticky fault: The remote sensor used for fusion has
2932 * fallen out of sync to the local sensor. A re-synchronization has
2933 * occurred, which may cause a discontinuity. This typically happens
2934 * if there is significant slop in the mechanism, or if the
2935 * RotorToSensorRatio configuration parameter is incorrect.
2936 *
2937 * This will wait up to #DefaultTimeoutSeconds.
2938 *
2939 * This is available in the configurator in case the user wants
2940 * to initialize their device entirely without passing a device
2941 * reference down to the code that performs the initialization.
2942 * In this case, the user passes down the configurator object
2943 * and performs all the initialization code on the object.
2944 *
2945 * \returns StatusCode of the set command
2946 */
2947 ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync()
2948 {
2949 return ClearStickyFault_FusedSensorOutOfSync(DefaultTimeoutSeconds);
2950 }
2951 /**
2952 * \brief Clear sticky fault: The remote sensor used for fusion has
2953 * fallen out of sync to the local sensor. A re-synchronization has
2954 * occurred, which may cause a discontinuity. This typically happens
2955 * if there is significant slop in the mechanism, or if the
2956 * RotorToSensorRatio configuration parameter is incorrect.
2957 *
2958 * This is available in the configurator in case the user wants
2959 * to initialize their device entirely without passing a device
2960 * reference down to the code that performs the initialization.
2961 * In this case, the user passes down the configurator object
2962 * and performs all the initialization code on the object.
2963 *
2964 * \param timeoutSeconds Maximum time to wait up to in seconds.
2965 * \returns StatusCode of the set command
2966 */
2967 ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync(units::time::second_t timeoutSeconds);
2968
2969 /**
2970 * \brief Clear sticky fault: Stator current limit occured.
2971 *
2972 * This will wait up to #DefaultTimeoutSeconds.
2973 *
2974 * This is available in the configurator in case the user wants
2975 * to initialize their device entirely without passing a device
2976 * reference down to the code that performs the initialization.
2977 * In this case, the user passes down the configurator object
2978 * and performs all the initialization code on the object.
2979 *
2980 * \returns StatusCode of the set command
2981 */
2982 ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit()
2983 {
2984 return ClearStickyFault_StatorCurrLimit(DefaultTimeoutSeconds);
2985 }
2986 /**
2987 * \brief Clear sticky fault: Stator current limit occured.
2988 *
2989 * This is available in the configurator in case the user wants
2990 * to initialize their device entirely without passing a device
2991 * reference down to the code that performs the initialization.
2992 * In this case, the user passes down the configurator object
2993 * and performs all the initialization code on the object.
2994 *
2995 * \param timeoutSeconds Maximum time to wait up to in seconds.
2996 * \returns StatusCode of the set command
2997 */
2998 ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit(units::time::second_t timeoutSeconds);
2999
3000 /**
3001 * \brief Clear sticky fault: Supply current limit occured.
3002 *
3003 * This will wait up to #DefaultTimeoutSeconds.
3004 *
3005 * This is available in the configurator in case the user wants
3006 * to initialize their device entirely without passing a device
3007 * reference down to the code that performs the initialization.
3008 * In this case, the user passes down the configurator object
3009 * and performs all the initialization code on the object.
3010 *
3011 * \returns StatusCode of the set command
3012 */
3013 ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit()
3014 {
3015 return ClearStickyFault_SupplyCurrLimit(DefaultTimeoutSeconds);
3016 }
3017 /**
3018 * \brief Clear sticky fault: Supply current limit occured.
3019 *
3020 * This is available in the configurator in case the user wants
3021 * to initialize their device entirely without passing a device
3022 * reference down to the code that performs the initialization.
3023 * In this case, the user passes down the configurator object
3024 * and performs all the initialization code on the object.
3025 *
3026 * \param timeoutSeconds Maximum time to wait up to in seconds.
3027 * \returns StatusCode of the set command
3028 */
3029 ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit(units::time::second_t timeoutSeconds);
3030
3031 /**
3032 * \brief Clear sticky fault: Using Fused CANcoder feature while
3033 * unlicensed. Device has fallen back to remote CANcoder.
3034 *
3035 * This will wait up to #DefaultTimeoutSeconds.
3036 *
3037 * This is available in the configurator in case the user wants
3038 * to initialize their device entirely without passing a device
3039 * reference down to the code that performs the initialization.
3040 * In this case, the user passes down the configurator object
3041 * and performs all the initialization code on the object.
3042 *
3043 * \returns StatusCode of the set command
3044 */
3045 ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed()
3046 {
3047 return ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(DefaultTimeoutSeconds);
3048 }
3049 /**
3050 * \brief Clear sticky fault: Using Fused CANcoder feature while
3051 * unlicensed. Device has fallen back to remote CANcoder.
3052 *
3053 * This is available in the configurator in case the user wants
3054 * to initialize their device entirely without passing a device
3055 * reference down to the code that performs the initialization.
3056 * In this case, the user passes down the configurator object
3057 * and performs all the initialization code on the object.
3058 *
3059 * \param timeoutSeconds Maximum time to wait up to in seconds.
3060 * \returns StatusCode of the set command
3061 */
3062 ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(units::time::second_t timeoutSeconds);
3063
3064 /**
3065 * \brief Clear sticky fault: Static brake was momentarily disabled
3066 * due to excessive braking current while disabled.
3067 *
3068 * This will wait up to #DefaultTimeoutSeconds.
3069 *
3070 * This is available in the configurator in case the user wants
3071 * to initialize their device entirely without passing a device
3072 * reference down to the code that performs the initialization.
3073 * In this case, the user passes down the configurator object
3074 * and performs all the initialization code on the object.
3075 *
3076 * \returns StatusCode of the set command
3077 */
3078 ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled()
3079 {
3080 return ClearStickyFault_StaticBrakeDisabled(DefaultTimeoutSeconds);
3081 }
3082 /**
3083 * \brief Clear sticky fault: Static brake was momentarily disabled
3084 * due to excessive braking current while disabled.
3085 *
3086 * This is available in the configurator in case the user wants
3087 * to initialize their device entirely without passing a device
3088 * reference down to the code that performs the initialization.
3089 * In this case, the user passes down the configurator object
3090 * and performs all the initialization code on the object.
3091 *
3092 * \param timeoutSeconds Maximum time to wait up to in seconds.
3093 * \returns StatusCode of the set command
3094 */
3095 ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled(units::time::second_t timeoutSeconds);
3096
3097 /**
3098 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
3099 * caused a brief loss of position data triggering a recovery while
3100 * not in motion. If the event occurs often, inspect for excess axial
3101 * force or sources of ESD at the rotor.
3102 *
3103 * This will wait up to #DefaultTimeoutSeconds.
3104 *
3105 * This is available in the configurator in case the user wants
3106 * to initialize their device entirely without passing a device
3107 * reference down to the code that performs the initialization.
3108 * In this case, the user passes down the configurator object
3109 * and performs all the initialization code on the object.
3110 *
3111 * \returns StatusCode of the set command
3112 */
3113 ctre::phoenix::StatusCode ClearStickyFault_RotorFault1()
3114 {
3115 return ClearStickyFault_RotorFault1(DefaultTimeoutSeconds);
3116 }
3117 /**
3118 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
3119 * caused a brief loss of position data triggering a recovery while
3120 * not in motion. If the event occurs often, inspect for excess axial
3121 * force or sources of ESD at the rotor.
3122 *
3123 * This is available in the configurator in case the user wants
3124 * to initialize their device entirely without passing a device
3125 * reference down to the code that performs the initialization.
3126 * In this case, the user passes down the configurator object
3127 * and performs all the initialization code on the object.
3128 *
3129 * \param timeoutSeconds Maximum time to wait up to in seconds.
3130 * \returns StatusCode of the set command
3131 */
3132 ctre::phoenix::StatusCode ClearStickyFault_RotorFault1(units::time::second_t timeoutSeconds);
3133
3134 /**
3135 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
3136 * caused a brief loss of position data triggering a recovery while in
3137 * motion. If the event occurs often, inspect for excess axial force
3138 * or sources of ESD at the rotor.
3139 *
3140 * This will wait up to #DefaultTimeoutSeconds.
3141 *
3142 * This is available in the configurator in case the user wants
3143 * to initialize their device entirely without passing a device
3144 * reference down to the code that performs the initialization.
3145 * In this case, the user passes down the configurator object
3146 * and performs all the initialization code on the object.
3147 *
3148 * \returns StatusCode of the set command
3149 */
3150 ctre::phoenix::StatusCode ClearStickyFault_RotorFault2()
3151 {
3152 return ClearStickyFault_RotorFault2(DefaultTimeoutSeconds);
3153 }
3154 /**
3155 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
3156 * caused a brief loss of position data triggering a recovery while in
3157 * motion. If the event occurs often, inspect for excess axial force
3158 * or sources of ESD at the rotor.
3159 *
3160 * This is available in the configurator in case the user wants
3161 * to initialize their device entirely without passing a device
3162 * reference down to the code that performs the initialization.
3163 * In this case, the user passes down the configurator object
3164 * and performs all the initialization code on the object.
3165 *
3166 * \param timeoutSeconds Maximum time to wait up to in seconds.
3167 * \returns StatusCode of the set command
3168 */
3169 ctre::phoenix::StatusCode ClearStickyFault_RotorFault2(units::time::second_t timeoutSeconds);
3170};
3171
3172}
3173
3174namespace hardware {
3175namespace core {
3176
3177#if defined(_WIN32) || defined(_WIN64)
3178#pragma warning(push)
3179#pragma warning(disable : 4250)
3180#endif
3181
3182/**
3183 * Class description for the Talon FX integrated motor controller.
3184 */
3185class CoreTalonFX : public ParentDevice, public traits::CommonTalonWithFOC
3186{
3187private:
3188 configs::TalonFXConfigurator _configs;
3189
3190public:
3191 /**
3192 * \brief The configuration class for this device.
3193 */
3194 using Configuration = configs::TalonFXConfiguration;
3195
3196 /**
3197 * Constructs a new Talon FX motor controller object.
3198 *
3199 * \param deviceId ID of the device, as configured in Phoenix Tuner
3200 * \param canbus The CAN bus this device is on
3201 */
3202 CoreTalonFX(int deviceId, CANBus canbus = {});
3203
3204 /**
3205 * Constructs a new Talon FX motor controller object.
3206 *
3207 * \param deviceId ID of the device, as configured in Phoenix Tuner
3208 * \param canbus Name of the CAN bus this device is on. Possible CAN bus strings are:
3209 * - "rio" for the native roboRIO CAN bus
3210 * - CANivore name or serial number
3211 * - SocketCAN interface (non-FRC Linux only)
3212 * - "*" for any CANivore seen by the program
3213 * - empty string (default) to select the default for the system:
3214 * - "rio" on roboRIO
3215 * - "can0" on Linux
3216 * - "*" on Windows
3217 *
3218 * \deprecated Constructing devices with a CAN bus string is deprecated for removal
3219 * in the 2027 season. Construct devices using a CANBus instance instead.
3220 */
3221 CoreTalonFX(int deviceId, std::string canbus);
3222
3223 /**
3224 * \brief Constructs a stubbed-out CoreTalonFX, where all status signals, controls,
3225 * configs, etc. perform no action and immediately return OK. This can be used to
3226 * silence error messages for devices that have been completely removed from the robot.
3227 *
3228 * \returns Stubbed-out CoreTalonFX
3229 */
3230 static CoreTalonFX None()
3231 {
3232 return CoreTalonFX{-1, CANBus{}};
3233 }
3234
3235 /**
3236 * \brief Gets the configurator for this TalonFX
3237 *
3238 * \details Gets the configurator for this TalonFX
3239 *
3240 * \returns Configurator for this TalonFX
3241 */
3242 configs::TalonFXConfigurator &GetConfigurator()
3243 {
3244 return _configs;
3245 }
3246
3247 /**
3248 * \brief Gets the configurator for this TalonFX
3249 *
3250 * \details Gets the configurator for this TalonFX
3251 *
3252 * \returns Configurator for this TalonFX
3253 */
3254 configs::TalonFXConfigurator const &GetConfigurator() const
3255 {
3256 return _configs;
3257 }
3258
3259
3260private:
3261 std::unique_ptr<sim::TalonFXSimState> _simState{};
3262public:
3263 /**
3264 * \brief Get the simulation state for this device.
3265 *
3266 * \details This function reuses an allocated simulation
3267 * state object, so it is safe to call this function multiple
3268 * times in a robot loop.
3269 *
3270 * \returns Simulation state
3271 */
3272 sim::TalonFXSimState &GetSimState()
3273 {
3274 if (_simState == nullptr)
3275 _simState = std::make_unique<sim::TalonFXSimState>(*this);
3276 return *_simState;
3277 }
3278
3279
3280
3281 /**
3282 * \brief App Major Version number.
3283 *
3284 * - Minimum Value: 0
3285 * - Maximum Value: 255
3286 * - Default Value: 0
3287 * - Units:
3288 *
3289 * Default Rates:
3290 * - CAN: 4.0 Hz
3291 *
3292 * This refreshes and returns a cached StatusSignal object.
3293 *
3294 * \param refresh Whether to refresh the StatusSignal before returning it;
3295 * defaults to true
3296 * \returns VersionMajor Status Signal Object
3297 */
3298 StatusSignal<int> &GetVersionMajor(bool refresh = true) final;
3299
3300 /**
3301 * \brief App Minor Version number.
3302 *
3303 * - Minimum Value: 0
3304 * - Maximum Value: 255
3305 * - Default Value: 0
3306 * - Units:
3307 *
3308 * Default Rates:
3309 * - CAN: 4.0 Hz
3310 *
3311 * This refreshes and returns a cached StatusSignal object.
3312 *
3313 * \param refresh Whether to refresh the StatusSignal before returning it;
3314 * defaults to true
3315 * \returns VersionMinor Status Signal Object
3316 */
3317 StatusSignal<int> &GetVersionMinor(bool refresh = true) final;
3318
3319 /**
3320 * \brief App Bugfix Version number.
3321 *
3322 * - Minimum Value: 0
3323 * - Maximum Value: 255
3324 * - Default Value: 0
3325 * - Units:
3326 *
3327 * Default Rates:
3328 * - CAN: 4.0 Hz
3329 *
3330 * This refreshes and returns a cached StatusSignal object.
3331 *
3332 * \param refresh Whether to refresh the StatusSignal before returning it;
3333 * defaults to true
3334 * \returns VersionBugfix Status Signal Object
3335 */
3336 StatusSignal<int> &GetVersionBugfix(bool refresh = true) final;
3337
3338 /**
3339 * \brief App Build Version number.
3340 *
3341 * - Minimum Value: 0
3342 * - Maximum Value: 255
3343 * - Default Value: 0
3344 * - Units:
3345 *
3346 * Default Rates:
3347 * - CAN: 4.0 Hz
3348 *
3349 * This refreshes and returns a cached StatusSignal object.
3350 *
3351 * \param refresh Whether to refresh the StatusSignal before returning it;
3352 * defaults to true
3353 * \returns VersionBuild Status Signal Object
3354 */
3355 StatusSignal<int> &GetVersionBuild(bool refresh = true) final;
3356
3357 /**
3358 * \brief Full Version of firmware in device. The format is a four
3359 * byte value.
3360 *
3361 * - Minimum Value: 0
3362 * - Maximum Value: 4294967295
3363 * - Default Value: 0
3364 * - Units:
3365 *
3366 * Default Rates:
3367 * - CAN: 4.0 Hz
3368 *
3369 * This refreshes and returns a cached StatusSignal object.
3370 *
3371 * \param refresh Whether to refresh the StatusSignal before returning it;
3372 * defaults to true
3373 * \returns Version Status Signal Object
3374 */
3375 StatusSignal<int> &GetVersion(bool refresh = true) final;
3376
3377 /**
3378 * \brief Integer representing all fault flags reported by the device.
3379 *
3380 * \details These are device specific and are not used directly in
3381 * typical applications. Use the signal specific GetFault_*() methods
3382 * instead.
3383 *
3384 * - Minimum Value: 0
3385 * - Maximum Value: 4294967295
3386 * - Default Value: 0
3387 * - Units:
3388 *
3389 * Default Rates:
3390 * - CAN: 4.0 Hz
3391 *
3392 * This refreshes and returns a cached StatusSignal object.
3393 *
3394 * \param refresh Whether to refresh the StatusSignal before returning it;
3395 * defaults to true
3396 * \returns FaultField Status Signal Object
3397 */
3398 StatusSignal<int> &GetFaultField(bool refresh = true) final;
3399
3400 /**
3401 * \brief Integer representing all (persistent) sticky fault flags
3402 * reported by the device.
3403 *
3404 * \details These are device specific and are not used directly in
3405 * typical applications. Use the signal specific GetStickyFault_*()
3406 * methods instead.
3407 *
3408 * - Minimum Value: 0
3409 * - Maximum Value: 4294967295
3410 * - Default Value: 0
3411 * - Units:
3412 *
3413 * Default Rates:
3414 * - CAN: 4.0 Hz
3415 *
3416 * This refreshes and returns a cached StatusSignal object.
3417 *
3418 * \param refresh Whether to refresh the StatusSignal before returning it;
3419 * defaults to true
3420 * \returns StickyFaultField Status Signal Object
3421 */
3422 StatusSignal<int> &GetStickyFaultField(bool refresh = true) final;
3423
3424 /**
3425 * \brief The applied (output) motor voltage.
3426 *
3427 * - Minimum Value: -40.96
3428 * - Maximum Value: 40.95
3429 * - Default Value: 0
3430 * - Units: V
3431 *
3432 * Default Rates:
3433 * - CAN 2.0: 100.0 Hz
3434 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3435 *
3436 * This refreshes and returns a cached StatusSignal object.
3437 *
3438 * \param refresh Whether to refresh the StatusSignal before returning it;
3439 * defaults to true
3440 * \returns MotorVoltage Status Signal Object
3441 */
3442 StatusSignal<units::voltage::volt_t> &GetMotorVoltage(bool refresh = true) final;
3443
3444 /**
3445 * \brief Forward Limit Pin.
3446 *
3447 *
3448 * Default Rates:
3449 * - CAN 2.0: 100.0 Hz
3450 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3451 *
3452 * This refreshes and returns a cached StatusSignal object.
3453 *
3454 * \param refresh Whether to refresh the StatusSignal before returning it;
3455 * defaults to true
3456 * \returns ForwardLimit Status Signal Object
3457 */
3458 StatusSignal<signals::ForwardLimitValue> &GetForwardLimit(bool refresh = true) final;
3459
3460 /**
3461 * \brief Reverse Limit Pin.
3462 *
3463 *
3464 * Default Rates:
3465 * - CAN 2.0: 100.0 Hz
3466 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3467 *
3468 * This refreshes and returns a cached StatusSignal object.
3469 *
3470 * \param refresh Whether to refresh the StatusSignal before returning it;
3471 * defaults to true
3472 * \returns ReverseLimit Status Signal Object
3473 */
3474 StatusSignal<signals::ReverseLimitValue> &GetReverseLimit(bool refresh = true) final;
3475
3476 /**
3477 * \brief The applied rotor polarity as seen from the front of the
3478 * motor. This typically is determined by the Inverted config, but
3479 * can be overridden if using Follower features.
3480 *
3481 *
3482 * Default Rates:
3483 * - CAN 2.0: 100.0 Hz
3484 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3485 *
3486 * This refreshes and returns a cached StatusSignal object.
3487 *
3488 * \param refresh Whether to refresh the StatusSignal before returning it;
3489 * defaults to true
3490 * \returns AppliedRotorPolarity Status Signal Object
3491 */
3492 StatusSignal<signals::AppliedRotorPolarityValue> &GetAppliedRotorPolarity(bool refresh = true) final;
3493
3494 /**
3495 * \brief The applied motor duty cycle.
3496 *
3497 * - Minimum Value: -2.0
3498 * - Maximum Value: 1.9990234375
3499 * - Default Value: 0
3500 * - Units: fractional
3501 *
3502 * Default Rates:
3503 * - CAN 2.0: 100.0 Hz
3504 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3505 *
3506 * This refreshes and returns a cached StatusSignal object.
3507 *
3508 * \param refresh Whether to refresh the StatusSignal before returning it;
3509 * defaults to true
3510 * \returns DutyCycle Status Signal Object
3511 */
3512 StatusSignal<units::dimensionless::scalar_t> &GetDutyCycle(bool refresh = true) final;
3513
3514 /**
3515 * \brief Current corresponding to the torque output by the motor.
3516 * Similar to StatorCurrent. Users will likely prefer this current to
3517 * calculate the applied torque to the rotor.
3518 *
3519 * \details Stator current where positive current means torque is
3520 * applied in the forward direction as determined by the Inverted
3521 * setting.
3522 *
3523 * - Minimum Value: -327.68
3524 * - Maximum Value: 327.67
3525 * - Default Value: 0
3526 * - Units: A
3527 *
3528 * Default Rates:
3529 * - CAN 2.0: 100.0 Hz
3530 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3531 *
3532 * This refreshes and returns a cached StatusSignal object.
3533 *
3534 * \param refresh Whether to refresh the StatusSignal before returning it;
3535 * defaults to true
3536 * \returns TorqueCurrent Status Signal Object
3537 */
3538 StatusSignal<units::current::ampere_t> &GetTorqueCurrent(bool refresh = true) final;
3539
3540 /**
3541 * \brief Current corresponding to the stator windings. Similar to
3542 * TorqueCurrent. Users will likely prefer TorqueCurrent over
3543 * StatorCurrent.
3544 *
3545 * \details Stator current where Positive current indicates motoring
3546 * regardless of direction. Negative current indicates regenerative
3547 * braking regardless of direction.
3548 *
3549 * - Minimum Value: -327.68
3550 * - Maximum Value: 327.66
3551 * - Default Value: 0
3552 * - Units: A
3553 *
3554 * Default Rates:
3555 * - CAN 2.0: 4.0 Hz
3556 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3557 *
3558 * This refreshes and returns a cached StatusSignal object.
3559 *
3560 * \param refresh Whether to refresh the StatusSignal before returning it;
3561 * defaults to true
3562 * \returns StatorCurrent Status Signal Object
3563 */
3564 StatusSignal<units::current::ampere_t> &GetStatorCurrent(bool refresh = true) final;
3565
3566 /**
3567 * \brief Measured supply side current.
3568 *
3569 * - Minimum Value: -327.68
3570 * - Maximum Value: 327.66
3571 * - Default Value: 0
3572 * - Units: A
3573 *
3574 * Default Rates:
3575 * - CAN 2.0: 4.0 Hz
3576 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3577 *
3578 * This refreshes and returns a cached StatusSignal object.
3579 *
3580 * \param refresh Whether to refresh the StatusSignal before returning it;
3581 * defaults to true
3582 * \returns SupplyCurrent Status Signal Object
3583 */
3584 StatusSignal<units::current::ampere_t> &GetSupplyCurrent(bool refresh = true) final;
3585
3586 /**
3587 * \brief Measured supply voltage to the device.
3588 *
3589 * - Minimum Value: 4
3590 * - Maximum Value: 29.575
3591 * - Default Value: 4
3592 * - Units: V
3593 *
3594 * Default Rates:
3595 * - CAN 2.0: 4.0 Hz
3596 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3597 *
3598 * This refreshes and returns a cached StatusSignal object.
3599 *
3600 * \param refresh Whether to refresh the StatusSignal before returning it;
3601 * defaults to true
3602 * \returns SupplyVoltage Status Signal Object
3603 */
3604 StatusSignal<units::voltage::volt_t> &GetSupplyVoltage(bool refresh = true) final;
3605
3606 /**
3607 * \brief Temperature of device.
3608 *
3609 * \details This is the temperature that the device measures itself to
3610 * be at. Similar to Processor Temperature.
3611 *
3612 * - Minimum Value: 0.0
3613 * - Maximum Value: 255.0
3614 * - Default Value: 0
3615 * - Units: ℃
3616 *
3617 * Default Rates:
3618 * - CAN 2.0: 4.0 Hz
3619 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3620 *
3621 * This refreshes and returns a cached StatusSignal object.
3622 *
3623 * \param refresh Whether to refresh the StatusSignal before returning it;
3624 * defaults to true
3625 * \returns DeviceTemp Status Signal Object
3626 */
3627 StatusSignal<units::temperature::celsius_t> &GetDeviceTemp(bool refresh = true) final;
3628
3629 /**
3630 * \brief Temperature of the processor.
3631 *
3632 * \details This is the temperature that the processor measures itself
3633 * to be at. Similar to Device Temperature.
3634 *
3635 * - Minimum Value: 0.0
3636 * - Maximum Value: 255.0
3637 * - Default Value: 0
3638 * - Units: ℃
3639 *
3640 * Default Rates:
3641 * - CAN 2.0: 4.0 Hz
3642 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3643 *
3644 * This refreshes and returns a cached StatusSignal object.
3645 *
3646 * \param refresh Whether to refresh the StatusSignal before returning it;
3647 * defaults to true
3648 * \returns ProcessorTemp Status Signal Object
3649 */
3650 StatusSignal<units::temperature::celsius_t> &GetProcessorTemp(bool refresh = true) final;
3651
3652 /**
3653 * \brief Velocity of the motor rotor. This velocity is not affected
3654 * by any feedback configs.
3655 *
3656 * - Minimum Value: -512.0
3657 * - Maximum Value: 511.998046875
3658 * - Default Value: 0
3659 * - Units: rotations per second
3660 *
3661 * Default Rates:
3662 * - CAN 2.0: 4.0 Hz
3663 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3664 *
3665 * This refreshes and returns a cached StatusSignal object.
3666 *
3667 * \param refresh Whether to refresh the StatusSignal before returning it;
3668 * defaults to true
3669 * \returns RotorVelocity Status Signal Object
3670 */
3671 StatusSignal<units::angular_velocity::turns_per_second_t> &GetRotorVelocity(bool refresh = true) final;
3672
3673 /**
3674 * \brief Position of the motor rotor. This position is only affected
3675 * by the RotorOffset config and calls to setPosition.
3676 *
3677 * - Minimum Value: -16384.0
3678 * - Maximum Value: 16383.999755859375
3679 * - Default Value: 0
3680 * - Units: rotations
3681 *
3682 * Default Rates:
3683 * - CAN 2.0: 4.0 Hz
3684 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3685 *
3686 * This refreshes and returns a cached StatusSignal object.
3687 *
3688 * \param refresh Whether to refresh the StatusSignal before returning it;
3689 * defaults to true
3690 * \returns RotorPosition Status Signal Object
3691 */
3692 StatusSignal<units::angle::turn_t> &GetRotorPosition(bool refresh = true) final;
3693
3694 /**
3695 * \brief Velocity of the device in mechanism rotations per second.
3696 * This can be the velocity of a remote sensor and is affected by the
3697 * RotorToSensorRatio and SensorToMechanismRatio configs.
3698 *
3699 * - Minimum Value: -512.0
3700 * - Maximum Value: 511.998046875
3701 * - Default Value: 0
3702 * - Units: rotations per second
3703 *
3704 * Default Rates:
3705 * - CAN 2.0: 50.0 Hz
3706 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3707 *
3708 * This refreshes and returns a cached StatusSignal object.
3709 *
3710 * \param refresh Whether to refresh the StatusSignal before returning it;
3711 * defaults to true
3712 * \returns Velocity Status Signal Object
3713 */
3714 StatusSignal<units::angular_velocity::turns_per_second_t> &GetVelocity(bool refresh = true) final;
3715
3716 /**
3717 * \brief Position of the device in mechanism rotations. This can be
3718 * the position of a remote sensor and is affected by the
3719 * RotorToSensorRatio and SensorToMechanismRatio configs, as well as
3720 * calls to setPosition.
3721 *
3722 * - Minimum Value: -16384.0
3723 * - Maximum Value: 16383.999755859375
3724 * - Default Value: 0
3725 * - Units: rotations
3726 *
3727 * Default Rates:
3728 * - CAN 2.0: 50.0 Hz
3729 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3730 *
3731 * This refreshes and returns a cached StatusSignal object.
3732 *
3733 * \param refresh Whether to refresh the StatusSignal before returning it;
3734 * defaults to true
3735 * \returns Position Status Signal Object
3736 */
3737 StatusSignal<units::angle::turn_t> &GetPosition(bool refresh = true) final;
3738
3739 /**
3740 * \brief Acceleration of the device in mechanism rotations per
3741 * second². This can be the acceleration of a remote sensor and is
3742 * affected by the RotorToSensorRatio and SensorToMechanismRatio
3743 * configs.
3744 *
3745 * - Minimum Value: -2048.0
3746 * - Maximum Value: 2047.75
3747 * - Default Value: 0
3748 * - Units: rotations per second²
3749 *
3750 * Default Rates:
3751 * - CAN 2.0: 50.0 Hz
3752 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3753 *
3754 * This refreshes and returns a cached StatusSignal object.
3755 *
3756 * \param refresh Whether to refresh the StatusSignal before returning it;
3757 * defaults to true
3758 * \returns Acceleration Status Signal Object
3759 */
3760 StatusSignal<units::angular_acceleration::turns_per_second_squared_t> &GetAcceleration(bool refresh = true) final;
3761
3762 /**
3763 * \brief The active control mode of the motor controller.
3764 *
3765 *
3766 * Default Rates:
3767 * - CAN 2.0: 4.0 Hz
3768 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3769 *
3770 * This refreshes and returns a cached StatusSignal object.
3771 *
3772 * \param refresh Whether to refresh the StatusSignal before returning it;
3773 * defaults to true
3774 * \returns ControlMode Status Signal Object
3775 */
3776 StatusSignal<signals::ControlModeValue> &GetControlMode(bool refresh = true) final;
3777
3778 /**
3779 * \brief Check if the Motion Magic® profile has reached the target.
3780 * This is equivalent to checking that MotionMagicIsRunning, the
3781 * ClosedLoopReference is the target, and the ClosedLoopReferenceSlope
3782 * is 0.
3783 *
3784 * - Default Value: False
3785 *
3786 * Default Rates:
3787 * - CAN 2.0: 4.0 Hz
3788 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3789 *
3790 * This refreshes and returns a cached StatusSignal object.
3791 *
3792 * \param refresh Whether to refresh the StatusSignal before returning it;
3793 * defaults to true
3794 * \returns MotionMagicAtTarget Status Signal Object
3795 */
3796 StatusSignal<bool> &GetMotionMagicAtTarget(bool refresh = true) final;
3797
3798 /**
3799 * \brief Check if Motion Magic® is running. This is equivalent to
3800 * checking that the reported control mode is a Motion Magic® based
3801 * mode.
3802 *
3803 * - Default Value: False
3804 *
3805 * Default Rates:
3806 * - CAN 2.0: 4.0 Hz
3807 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3808 *
3809 * This refreshes and returns a cached StatusSignal object.
3810 *
3811 * \param refresh Whether to refresh the StatusSignal before returning it;
3812 * defaults to true
3813 * \returns MotionMagicIsRunning Status Signal Object
3814 */
3815 StatusSignal<bool> &GetMotionMagicIsRunning(bool refresh = true) final;
3816
3817 /**
3818 * \brief Indicates if the robot is enabled.
3819 *
3820 *
3821 * Default Rates:
3822 * - CAN 2.0: 4.0 Hz
3823 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3824 *
3825 * This refreshes and returns a cached StatusSignal object.
3826 *
3827 * \param refresh Whether to refresh the StatusSignal before returning it;
3828 * defaults to true
3829 * \returns RobotEnable Status Signal Object
3830 */
3831 StatusSignal<signals::RobotEnableValue> &GetRobotEnable(bool refresh = true) final;
3832
3833 /**
3834 * \brief Indicates if device is actuator enabled.
3835 *
3836 *
3837 * Default Rates:
3838 * - CAN 2.0: 4.0 Hz
3839 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3840 *
3841 * This refreshes and returns a cached StatusSignal object.
3842 *
3843 * \param refresh Whether to refresh the StatusSignal before returning it;
3844 * defaults to true
3845 * \returns DeviceEnable Status Signal Object
3846 */
3847 StatusSignal<signals::DeviceEnableValue> &GetDeviceEnable(bool refresh = true) final;
3848
3849 /**
3850 * \brief The slot that the closed-loop PID is using.
3851 *
3852 * - Minimum Value: 0
3853 * - Maximum Value: 2
3854 * - Default Value: 0
3855 * - Units:
3856 *
3857 * Default Rates:
3858 * - CAN 2.0: 4.0 Hz
3859 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3860 *
3861 * This refreshes and returns a cached StatusSignal object.
3862 *
3863 * \param refresh Whether to refresh the StatusSignal before returning it;
3864 * defaults to true
3865 * \returns ClosedLoopSlot Status Signal Object
3866 */
3867 StatusSignal<int> &GetClosedLoopSlot(bool refresh = true) final;
3868
3869 /**
3870 * \brief Assess the status of the motor output with respect to load
3871 * and supply.
3872 *
3873 * \details This routine can be used to determine the general status
3874 * of motor commutation.
3875 *
3876 *
3877 * Default Rates:
3878 * - CAN 2.0: 4.0 Hz
3879 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3880 *
3881 * This refreshes and returns a cached StatusSignal object.
3882 *
3883 * \param refresh Whether to refresh the StatusSignal before returning it;
3884 * defaults to true
3885 * \returns MotorOutputStatus Status Signal Object
3886 */
3887 StatusSignal<signals::MotorOutputStatusValue> &GetMotorOutputStatus(bool refresh = true) final;
3888
3889 /**
3890 * \brief The active control mode of the differential controller.
3891 *
3892 *
3893 * Default Rates:
3894 * - CAN 2.0: 100.0 Hz
3895 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3896 *
3897 * This refreshes and returns a cached StatusSignal object.
3898 *
3899 * \param refresh Whether to refresh the StatusSignal before returning it;
3900 * defaults to true
3901 * \returns DifferentialControlMode Status Signal Object
3902 */
3903 StatusSignal<signals::DifferentialControlModeValue> &GetDifferentialControlMode(bool refresh = true) final;
3904
3905 /**
3906 * \brief Average component of the differential velocity of device.
3907 *
3908 * - Minimum Value: -512.0
3909 * - Maximum Value: 511.998046875
3910 * - Default Value: 0
3911 * - Units: rotations per second
3912 *
3913 * Default Rates:
3914 * - CAN 2.0: 4.0 Hz
3915 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3916 *
3917 * This refreshes and returns a cached StatusSignal object.
3918 *
3919 * \param refresh Whether to refresh the StatusSignal before returning it;
3920 * defaults to true
3921 * \returns DifferentialAverageVelocity Status Signal Object
3922 */
3923 StatusSignal<units::angular_velocity::turns_per_second_t> &GetDifferentialAverageVelocity(bool refresh = true) final;
3924
3925 /**
3926 * \brief Average component of the differential position of device.
3927 *
3928 * - Minimum Value: -16384.0
3929 * - Maximum Value: 16383.999755859375
3930 * - Default Value: 0
3931 * - Units: rotations
3932 *
3933 * Default Rates:
3934 * - CAN 2.0: 4.0 Hz
3935 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3936 *
3937 * This refreshes and returns a cached StatusSignal object.
3938 *
3939 * \param refresh Whether to refresh the StatusSignal before returning it;
3940 * defaults to true
3941 * \returns DifferentialAveragePosition Status Signal Object
3942 */
3943 StatusSignal<units::angle::turn_t> &GetDifferentialAveragePosition(bool refresh = true) final;
3944
3945 /**
3946 * \brief Difference component of the differential velocity of device.
3947 *
3948 * - Minimum Value: -512.0
3949 * - Maximum Value: 511.998046875
3950 * - Default Value: 0
3951 * - Units: rotations per second
3952 *
3953 * Default Rates:
3954 * - CAN 2.0: 4.0 Hz
3955 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3956 *
3957 * This refreshes and returns a cached StatusSignal object.
3958 *
3959 * \param refresh Whether to refresh the StatusSignal before returning it;
3960 * defaults to true
3961 * \returns DifferentialDifferenceVelocity Status Signal Object
3962 */
3963 StatusSignal<units::angular_velocity::turns_per_second_t> &GetDifferentialDifferenceVelocity(bool refresh = true) final;
3964
3965 /**
3966 * \brief Difference component of the differential position of device.
3967 *
3968 * - Minimum Value: -16384.0
3969 * - Maximum Value: 16383.999755859375
3970 * - Default Value: 0
3971 * - Units: rotations
3972 *
3973 * Default Rates:
3974 * - CAN 2.0: 4.0 Hz
3975 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3976 *
3977 * This refreshes and returns a cached StatusSignal object.
3978 *
3979 * \param refresh Whether to refresh the StatusSignal before returning it;
3980 * defaults to true
3981 * \returns DifferentialDifferencePosition Status Signal Object
3982 */
3983 StatusSignal<units::angle::turn_t> &GetDifferentialDifferencePosition(bool refresh = true) final;
3984
3985 /**
3986 * \brief The slot that the closed-loop differential PID is using.
3987 *
3988 * - Minimum Value: 0
3989 * - Maximum Value: 2
3990 * - Default Value: 0
3991 * - Units:
3992 *
3993 * Default Rates:
3994 * - CAN 2.0: 4.0 Hz
3995 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
3996 *
3997 * This refreshes and returns a cached StatusSignal object.
3998 *
3999 * \param refresh Whether to refresh the StatusSignal before returning it;
4000 * defaults to true
4001 * \returns DifferentialClosedLoopSlot Status Signal Object
4002 */
4003 StatusSignal<int> &GetDifferentialClosedLoopSlot(bool refresh = true) final;
4004
4005 /**
4006 * \brief The torque constant (K_T) of the motor.
4007 *
4008 * - Minimum Value: 0.0
4009 * - Maximum Value: 0.025500000000000002
4010 * - Default Value: 0
4011 * - Units: Nm/A
4012 *
4013 * Default Rates:
4014 * - CAN: 4.0 Hz
4015 *
4016 * This refreshes and returns a cached StatusSignal object.
4017 *
4018 * \param refresh Whether to refresh the StatusSignal before returning it;
4019 * defaults to true
4020 * \returns MotorKT Status Signal Object
4021 */
4022 StatusSignal<ctre::unit::newton_meters_per_ampere_t> &GetMotorKT(bool refresh = true) final;
4023
4024 /**
4025 * \brief The velocity constant (K_V) of the motor.
4026 *
4027 * - Minimum Value: 0.0
4028 * - Maximum Value: 2047.0
4029 * - Default Value: 0
4030 * - Units: RPM/V
4031 *
4032 * Default Rates:
4033 * - CAN: 4.0 Hz
4034 *
4035 * This refreshes and returns a cached StatusSignal object.
4036 *
4037 * \param refresh Whether to refresh the StatusSignal before returning it;
4038 * defaults to true
4039 * \returns MotorKV Status Signal Object
4040 */
4041 StatusSignal<ctre::unit::rpm_per_volt_t> &GetMotorKV(bool refresh = true) final;
4042
4043 /**
4044 * \brief The stall current of the motor at 12 V output.
4045 *
4046 * - Minimum Value: 0.0
4047 * - Maximum Value: 1023.0
4048 * - Default Value: 0
4049 * - Units: A
4050 *
4051 * Default Rates:
4052 * - CAN: 4.0 Hz
4053 *
4054 * This refreshes and returns a cached StatusSignal object.
4055 *
4056 * \param refresh Whether to refresh the StatusSignal before returning it;
4057 * defaults to true
4058 * \returns MotorStallCurrent Status Signal Object
4059 */
4060 StatusSignal<units::current::ampere_t> &GetMotorStallCurrent(bool refresh = true) final;
4061
4062 /**
4063 * \brief The applied output of the bridge.
4064 *
4065 *
4066 * Default Rates:
4067 * - CAN 2.0: 100.0 Hz
4068 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
4069 *
4070 * This refreshes and returns a cached StatusSignal object.
4071 *
4072 * \param refresh Whether to refresh the StatusSignal before returning it;
4073 * defaults to true
4074 * \returns BridgeOutput Status Signal Object
4075 */
4076 StatusSignal<signals::BridgeOutputValue> &GetBridgeOutput(bool refresh = true) final;
4077
4078 /**
4079 * \brief Whether the device is Phoenix Pro licensed.
4080 *
4081 * - Default Value: False
4082 *
4083 * Default Rates:
4084 * - CAN: 4.0 Hz
4085 *
4086 * This refreshes and returns a cached StatusSignal object.
4087 *
4088 * \param refresh Whether to refresh the StatusSignal before returning it;
4089 * defaults to true
4090 * \returns IsProLicensed Status Signal Object
4091 */
4092 StatusSignal<bool> &GetIsProLicensed(bool refresh = true) final;
4093
4094 /**
4095 * \brief Temperature of device from second sensor.
4096 *
4097 * \details Newer versions of Talon have multiple temperature
4098 * measurement methods.
4099 *
4100 * - Minimum Value: 0.0
4101 * - Maximum Value: 255.0
4102 * - Default Value: 0
4103 * - Units: ℃
4104 *
4105 * Default Rates:
4106 * - CAN 2.0: 4.0 Hz
4107 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
4108 *
4109 * This refreshes and returns a cached StatusSignal object.
4110 *
4111 * \param refresh Whether to refresh the StatusSignal before returning it;
4112 * defaults to true
4113 * \returns AncillaryDeviceTemp Status Signal Object
4114 */
4115 StatusSignal<units::temperature::celsius_t> &GetAncillaryDeviceTemp(bool refresh = true) final;
4116
4117 /**
4118 * \brief The type of motor attached to the Talon.
4119 *
4120 * \details This can be used to determine what motor is attached to
4121 * the Talon FX. Return will be "Unknown" if firmware is too old or
4122 * device is not present.
4123 *
4124 *
4125 * Default Rates:
4126 * - CAN 2.0: 4.0 Hz
4127 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
4128 *
4129 * This refreshes and returns a cached StatusSignal object.
4130 *
4131 * \param refresh Whether to refresh the StatusSignal before returning it;
4132 * defaults to true
4133 * \returns ConnectedMotor Status Signal Object
4134 */
4135 StatusSignal<signals::ConnectedMotorValue> &GetConnectedMotor(bool refresh = true) final;
4136
4137 /**
4138 * \brief Hardware fault occurred
4139 *
4140 * - Default Value: False
4141 *
4142 * Default Rates:
4143 * - CAN: 4.0 Hz
4144 *
4145 * This refreshes and returns a cached StatusSignal object.
4146 *
4147 * \param refresh Whether to refresh the StatusSignal before returning it;
4148 * defaults to true
4149 * \returns Fault_Hardware Status Signal Object
4150 */
4151 StatusSignal<bool> &GetFault_Hardware(bool refresh = true) final;
4152
4153 /**
4154 * \brief Hardware fault occurred
4155 *
4156 * - Default Value: False
4157 *
4158 * Default Rates:
4159 * - CAN: 4.0 Hz
4160 *
4161 * This refreshes and returns a cached StatusSignal object.
4162 *
4163 * \param refresh Whether to refresh the StatusSignal before returning it;
4164 * defaults to true
4165 * \returns StickyFault_Hardware Status Signal Object
4166 */
4167 StatusSignal<bool> &GetStickyFault_Hardware(bool refresh = true) final;
4168
4169 /**
4170 * \brief Processor temperature exceeded limit
4171 *
4172 * - Default Value: False
4173 *
4174 * Default Rates:
4175 * - CAN: 4.0 Hz
4176 *
4177 * This refreshes and returns a cached StatusSignal object.
4178 *
4179 * \param refresh Whether to refresh the StatusSignal before returning it;
4180 * defaults to true
4181 * \returns Fault_ProcTemp Status Signal Object
4182 */
4183 StatusSignal<bool> &GetFault_ProcTemp(bool refresh = true) final;
4184
4185 /**
4186 * \brief Processor temperature exceeded limit
4187 *
4188 * - Default Value: False
4189 *
4190 * Default Rates:
4191 * - CAN: 4.0 Hz
4192 *
4193 * This refreshes and returns a cached StatusSignal object.
4194 *
4195 * \param refresh Whether to refresh the StatusSignal before returning it;
4196 * defaults to true
4197 * \returns StickyFault_ProcTemp Status Signal Object
4198 */
4199 StatusSignal<bool> &GetStickyFault_ProcTemp(bool refresh = true) final;
4200
4201 /**
4202 * \brief Device temperature exceeded limit
4203 *
4204 * - Default Value: False
4205 *
4206 * Default Rates:
4207 * - CAN: 4.0 Hz
4208 *
4209 * This refreshes and returns a cached StatusSignal object.
4210 *
4211 * \param refresh Whether to refresh the StatusSignal before returning it;
4212 * defaults to true
4213 * \returns Fault_DeviceTemp Status Signal Object
4214 */
4215 StatusSignal<bool> &GetFault_DeviceTemp(bool refresh = true) final;
4216
4217 /**
4218 * \brief Device temperature exceeded limit
4219 *
4220 * - Default Value: False
4221 *
4222 * Default Rates:
4223 * - CAN: 4.0 Hz
4224 *
4225 * This refreshes and returns a cached StatusSignal object.
4226 *
4227 * \param refresh Whether to refresh the StatusSignal before returning it;
4228 * defaults to true
4229 * \returns StickyFault_DeviceTemp Status Signal Object
4230 */
4231 StatusSignal<bool> &GetStickyFault_DeviceTemp(bool refresh = true) final;
4232
4233 /**
4234 * \brief Device supply voltage dropped to near brownout levels
4235 *
4236 * - Default Value: False
4237 *
4238 * Default Rates:
4239 * - CAN: 4.0 Hz
4240 *
4241 * This refreshes and returns a cached StatusSignal object.
4242 *
4243 * \param refresh Whether to refresh the StatusSignal before returning it;
4244 * defaults to true
4245 * \returns Fault_Undervoltage Status Signal Object
4246 */
4247 StatusSignal<bool> &GetFault_Undervoltage(bool refresh = true) final;
4248
4249 /**
4250 * \brief Device supply voltage dropped to near brownout levels
4251 *
4252 * - Default Value: False
4253 *
4254 * Default Rates:
4255 * - CAN: 4.0 Hz
4256 *
4257 * This refreshes and returns a cached StatusSignal object.
4258 *
4259 * \param refresh Whether to refresh the StatusSignal before returning it;
4260 * defaults to true
4261 * \returns StickyFault_Undervoltage Status Signal Object
4262 */
4263 StatusSignal<bool> &GetStickyFault_Undervoltage(bool refresh = true) final;
4264
4265 /**
4266 * \brief Device boot while detecting the enable signal
4267 *
4268 * - Default Value: False
4269 *
4270 * Default Rates:
4271 * - CAN: 4.0 Hz
4272 *
4273 * This refreshes and returns a cached StatusSignal object.
4274 *
4275 * \param refresh Whether to refresh the StatusSignal before returning it;
4276 * defaults to true
4277 * \returns Fault_BootDuringEnable Status Signal Object
4278 */
4279 StatusSignal<bool> &GetFault_BootDuringEnable(bool refresh = true) final;
4280
4281 /**
4282 * \brief Device boot while detecting the enable signal
4283 *
4284 * - Default Value: False
4285 *
4286 * Default Rates:
4287 * - CAN: 4.0 Hz
4288 *
4289 * This refreshes and returns a cached StatusSignal object.
4290 *
4291 * \param refresh Whether to refresh the StatusSignal before returning it;
4292 * defaults to true
4293 * \returns StickyFault_BootDuringEnable Status Signal Object
4294 */
4295 StatusSignal<bool> &GetStickyFault_BootDuringEnable(bool refresh = true) final;
4296
4297 /**
4298 * \brief An unlicensed feature is in use, device may not behave as
4299 * expected.
4300 *
4301 * - Default Value: False
4302 *
4303 * Default Rates:
4304 * - CAN: 4.0 Hz
4305 *
4306 * This refreshes and returns a cached StatusSignal object.
4307 *
4308 * \param refresh Whether to refresh the StatusSignal before returning it;
4309 * defaults to true
4310 * \returns Fault_UnlicensedFeatureInUse Status Signal Object
4311 */
4312 StatusSignal<bool> &GetFault_UnlicensedFeatureInUse(bool refresh = true) final;
4313
4314 /**
4315 * \brief An unlicensed feature is in use, device may not behave as
4316 * expected.
4317 *
4318 * - Default Value: False
4319 *
4320 * Default Rates:
4321 * - CAN: 4.0 Hz
4322 *
4323 * This refreshes and returns a cached StatusSignal object.
4324 *
4325 * \param refresh Whether to refresh the StatusSignal before returning it;
4326 * defaults to true
4327 * \returns StickyFault_UnlicensedFeatureInUse Status Signal Object
4328 */
4329 StatusSignal<bool> &GetStickyFault_UnlicensedFeatureInUse(bool refresh = true) final;
4330
4331 /**
4332 * \brief Bridge was disabled most likely due to supply voltage
4333 * dropping too low.
4334 *
4335 * - Default Value: False
4336 *
4337 * Default Rates:
4338 * - CAN: 4.0 Hz
4339 *
4340 * This refreshes and returns a cached StatusSignal object.
4341 *
4342 * \param refresh Whether to refresh the StatusSignal before returning it;
4343 * defaults to true
4344 * \returns Fault_BridgeBrownout Status Signal Object
4345 */
4346 StatusSignal<bool> &GetFault_BridgeBrownout(bool refresh = true) final;
4347
4348 /**
4349 * \brief Bridge was disabled most likely due to supply voltage
4350 * dropping too low.
4351 *
4352 * - Default Value: False
4353 *
4354 * Default Rates:
4355 * - CAN: 4.0 Hz
4356 *
4357 * This refreshes and returns a cached StatusSignal object.
4358 *
4359 * \param refresh Whether to refresh the StatusSignal before returning it;
4360 * defaults to true
4361 * \returns StickyFault_BridgeBrownout Status Signal Object
4362 */
4363 StatusSignal<bool> &GetStickyFault_BridgeBrownout(bool refresh = true) final;
4364
4365 /**
4366 * \brief The remote sensor has reset.
4367 *
4368 * - Default Value: False
4369 *
4370 * Default Rates:
4371 * - CAN: 4.0 Hz
4372 *
4373 * This refreshes and returns a cached StatusSignal object.
4374 *
4375 * \param refresh Whether to refresh the StatusSignal before returning it;
4376 * defaults to true
4377 * \returns Fault_RemoteSensorReset Status Signal Object
4378 */
4379 StatusSignal<bool> &GetFault_RemoteSensorReset(bool refresh = true) final;
4380
4381 /**
4382 * \brief The remote sensor has reset.
4383 *
4384 * - Default Value: False
4385 *
4386 * Default Rates:
4387 * - CAN: 4.0 Hz
4388 *
4389 * This refreshes and returns a cached StatusSignal object.
4390 *
4391 * \param refresh Whether to refresh the StatusSignal before returning it;
4392 * defaults to true
4393 * \returns StickyFault_RemoteSensorReset Status Signal Object
4394 */
4395 StatusSignal<bool> &GetStickyFault_RemoteSensorReset(bool refresh = true) final;
4396
4397 /**
4398 * \brief The remote Talon used for differential control is not
4399 * present on CAN Bus.
4400 *
4401 * - Default Value: False
4402 *
4403 * Default Rates:
4404 * - CAN: 4.0 Hz
4405 *
4406 * This refreshes and returns a cached StatusSignal object.
4407 *
4408 * \param refresh Whether to refresh the StatusSignal before returning it;
4409 * defaults to true
4410 * \returns Fault_MissingDifferentialFX Status Signal Object
4411 */
4412 StatusSignal<bool> &GetFault_MissingDifferentialFX(bool refresh = true) final;
4413
4414 /**
4415 * \brief The remote Talon used for differential control is not
4416 * present on CAN Bus.
4417 *
4418 * - Default Value: False
4419 *
4420 * Default Rates:
4421 * - CAN: 4.0 Hz
4422 *
4423 * This refreshes and returns a cached StatusSignal object.
4424 *
4425 * \param refresh Whether to refresh the StatusSignal before returning it;
4426 * defaults to true
4427 * \returns StickyFault_MissingDifferentialFX Status Signal Object
4428 */
4429 StatusSignal<bool> &GetStickyFault_MissingDifferentialFX(bool refresh = true) final;
4430
4431 /**
4432 * \brief The remote sensor position has overflowed. Because of the
4433 * nature of remote sensors, it is possible for the remote sensor
4434 * position to overflow beyond what is supported by the status signal
4435 * frame. However, this is rare and cannot occur over the course of an
4436 * FRC match under normal use.
4437 *
4438 * - Default Value: False
4439 *
4440 * Default Rates:
4441 * - CAN: 4.0 Hz
4442 *
4443 * This refreshes and returns a cached StatusSignal object.
4444 *
4445 * \param refresh Whether to refresh the StatusSignal before returning it;
4446 * defaults to true
4447 * \returns Fault_RemoteSensorPosOverflow Status Signal Object
4448 */
4449 StatusSignal<bool> &GetFault_RemoteSensorPosOverflow(bool refresh = true) final;
4450
4451 /**
4452 * \brief The remote sensor position has overflowed. Because of the
4453 * nature of remote sensors, it is possible for the remote sensor
4454 * position to overflow beyond what is supported by the status signal
4455 * frame. However, this is rare and cannot occur over the course of an
4456 * FRC match under normal use.
4457 *
4458 * - Default Value: False
4459 *
4460 * Default Rates:
4461 * - CAN: 4.0 Hz
4462 *
4463 * This refreshes and returns a cached StatusSignal object.
4464 *
4465 * \param refresh Whether to refresh the StatusSignal before returning it;
4466 * defaults to true
4467 * \returns StickyFault_RemoteSensorPosOverflow Status Signal Object
4468 */
4469 StatusSignal<bool> &GetStickyFault_RemoteSensorPosOverflow(bool refresh = true) final;
4470
4471 /**
4472 * \brief Supply Voltage has exceeded the maximum voltage rating of
4473 * device.
4474 *
4475 * - Default Value: False
4476 *
4477 * Default Rates:
4478 * - CAN: 4.0 Hz
4479 *
4480 * This refreshes and returns a cached StatusSignal object.
4481 *
4482 * \param refresh Whether to refresh the StatusSignal before returning it;
4483 * defaults to true
4484 * \returns Fault_OverSupplyV Status Signal Object
4485 */
4486 StatusSignal<bool> &GetFault_OverSupplyV(bool refresh = true) final;
4487
4488 /**
4489 * \brief Supply Voltage has exceeded the maximum voltage rating of
4490 * device.
4491 *
4492 * - Default Value: False
4493 *
4494 * Default Rates:
4495 * - CAN: 4.0 Hz
4496 *
4497 * This refreshes and returns a cached StatusSignal object.
4498 *
4499 * \param refresh Whether to refresh the StatusSignal before returning it;
4500 * defaults to true
4501 * \returns StickyFault_OverSupplyV Status Signal Object
4502 */
4503 StatusSignal<bool> &GetStickyFault_OverSupplyV(bool refresh = true) final;
4504
4505 /**
4506 * \brief Supply Voltage is unstable. Ensure you are using a battery
4507 * and current limited power supply.
4508 *
4509 * - Default Value: False
4510 *
4511 * Default Rates:
4512 * - CAN: 4.0 Hz
4513 *
4514 * This refreshes and returns a cached StatusSignal object.
4515 *
4516 * \param refresh Whether to refresh the StatusSignal before returning it;
4517 * defaults to true
4518 * \returns Fault_UnstableSupplyV Status Signal Object
4519 */
4520 StatusSignal<bool> &GetFault_UnstableSupplyV(bool refresh = true) final;
4521
4522 /**
4523 * \brief Supply Voltage is unstable. Ensure you are using a battery
4524 * and current limited power supply.
4525 *
4526 * - Default Value: False
4527 *
4528 * Default Rates:
4529 * - CAN: 4.0 Hz
4530 *
4531 * This refreshes and returns a cached StatusSignal object.
4532 *
4533 * \param refresh Whether to refresh the StatusSignal before returning it;
4534 * defaults to true
4535 * \returns StickyFault_UnstableSupplyV Status Signal Object
4536 */
4537 StatusSignal<bool> &GetStickyFault_UnstableSupplyV(bool refresh = true) final;
4538
4539 /**
4540 * \brief Reverse limit switch has been asserted. Output is set to
4541 * neutral.
4542 *
4543 * - Default Value: False
4544 *
4545 * Default Rates:
4546 * - CAN: 4.0 Hz
4547 *
4548 * This refreshes and returns a cached StatusSignal object.
4549 *
4550 * \param refresh Whether to refresh the StatusSignal before returning it;
4551 * defaults to true
4552 * \returns Fault_ReverseHardLimit Status Signal Object
4553 */
4554 StatusSignal<bool> &GetFault_ReverseHardLimit(bool refresh = true) final;
4555
4556 /**
4557 * \brief Reverse limit switch has been asserted. Output is set to
4558 * neutral.
4559 *
4560 * - Default Value: False
4561 *
4562 * Default Rates:
4563 * - CAN: 4.0 Hz
4564 *
4565 * This refreshes and returns a cached StatusSignal object.
4566 *
4567 * \param refresh Whether to refresh the StatusSignal before returning it;
4568 * defaults to true
4569 * \returns StickyFault_ReverseHardLimit Status Signal Object
4570 */
4571 StatusSignal<bool> &GetStickyFault_ReverseHardLimit(bool refresh = true) final;
4572
4573 /**
4574 * \brief Forward limit switch has been asserted. Output is set to
4575 * neutral.
4576 *
4577 * - Default Value: False
4578 *
4579 * Default Rates:
4580 * - CAN: 4.0 Hz
4581 *
4582 * This refreshes and returns a cached StatusSignal object.
4583 *
4584 * \param refresh Whether to refresh the StatusSignal before returning it;
4585 * defaults to true
4586 * \returns Fault_ForwardHardLimit Status Signal Object
4587 */
4588 StatusSignal<bool> &GetFault_ForwardHardLimit(bool refresh = true) final;
4589
4590 /**
4591 * \brief Forward limit switch has been asserted. Output is set to
4592 * neutral.
4593 *
4594 * - Default Value: False
4595 *
4596 * Default Rates:
4597 * - CAN: 4.0 Hz
4598 *
4599 * This refreshes and returns a cached StatusSignal object.
4600 *
4601 * \param refresh Whether to refresh the StatusSignal before returning it;
4602 * defaults to true
4603 * \returns StickyFault_ForwardHardLimit Status Signal Object
4604 */
4605 StatusSignal<bool> &GetStickyFault_ForwardHardLimit(bool refresh = true) final;
4606
4607 /**
4608 * \brief Reverse soft limit has been asserted. Output is set to
4609 * neutral.
4610 *
4611 * - Default Value: False
4612 *
4613 * Default Rates:
4614 * - CAN: 4.0 Hz
4615 *
4616 * This refreshes and returns a cached StatusSignal object.
4617 *
4618 * \param refresh Whether to refresh the StatusSignal before returning it;
4619 * defaults to true
4620 * \returns Fault_ReverseSoftLimit Status Signal Object
4621 */
4622 StatusSignal<bool> &GetFault_ReverseSoftLimit(bool refresh = true) final;
4623
4624 /**
4625 * \brief Reverse soft limit has been asserted. Output is set to
4626 * neutral.
4627 *
4628 * - Default Value: False
4629 *
4630 * Default Rates:
4631 * - CAN: 4.0 Hz
4632 *
4633 * This refreshes and returns a cached StatusSignal object.
4634 *
4635 * \param refresh Whether to refresh the StatusSignal before returning it;
4636 * defaults to true
4637 * \returns StickyFault_ReverseSoftLimit Status Signal Object
4638 */
4639 StatusSignal<bool> &GetStickyFault_ReverseSoftLimit(bool refresh = true) final;
4640
4641 /**
4642 * \brief Forward soft limit has been asserted. Output is set to
4643 * neutral.
4644 *
4645 * - Default Value: False
4646 *
4647 * Default Rates:
4648 * - CAN: 4.0 Hz
4649 *
4650 * This refreshes and returns a cached StatusSignal object.
4651 *
4652 * \param refresh Whether to refresh the StatusSignal before returning it;
4653 * defaults to true
4654 * \returns Fault_ForwardSoftLimit Status Signal Object
4655 */
4656 StatusSignal<bool> &GetFault_ForwardSoftLimit(bool refresh = true) final;
4657
4658 /**
4659 * \brief Forward soft limit has been asserted. Output is set to
4660 * neutral.
4661 *
4662 * - Default Value: False
4663 *
4664 * Default Rates:
4665 * - CAN: 4.0 Hz
4666 *
4667 * This refreshes and returns a cached StatusSignal object.
4668 *
4669 * \param refresh Whether to refresh the StatusSignal before returning it;
4670 * defaults to true
4671 * \returns StickyFault_ForwardSoftLimit Status Signal Object
4672 */
4673 StatusSignal<bool> &GetStickyFault_ForwardSoftLimit(bool refresh = true) final;
4674
4675 /**
4676 * \brief The remote soft limit device is not present on CAN Bus.
4677 *
4678 * - Default Value: False
4679 *
4680 * Default Rates:
4681 * - CAN: 4.0 Hz
4682 *
4683 * This refreshes and returns a cached StatusSignal object.
4684 *
4685 * \param refresh Whether to refresh the StatusSignal before returning it;
4686 * defaults to true
4687 * \returns Fault_MissingSoftLimitRemote Status Signal Object
4688 */
4689 StatusSignal<bool> &GetFault_MissingSoftLimitRemote(bool refresh = true) final;
4690
4691 /**
4692 * \brief The remote soft limit device is not present on CAN Bus.
4693 *
4694 * - Default Value: False
4695 *
4696 * Default Rates:
4697 * - CAN: 4.0 Hz
4698 *
4699 * This refreshes and returns a cached StatusSignal object.
4700 *
4701 * \param refresh Whether to refresh the StatusSignal before returning it;
4702 * defaults to true
4703 * \returns StickyFault_MissingSoftLimitRemote Status Signal Object
4704 */
4705 StatusSignal<bool> &GetStickyFault_MissingSoftLimitRemote(bool refresh = true) final;
4706
4707 /**
4708 * \brief The remote limit switch device is not present on CAN Bus.
4709 *
4710 * - Default Value: False
4711 *
4712 * Default Rates:
4713 * - CAN: 4.0 Hz
4714 *
4715 * This refreshes and returns a cached StatusSignal object.
4716 *
4717 * \param refresh Whether to refresh the StatusSignal before returning it;
4718 * defaults to true
4719 * \returns Fault_MissingHardLimitRemote Status Signal Object
4720 */
4721 StatusSignal<bool> &GetFault_MissingHardLimitRemote(bool refresh = true) final;
4722
4723 /**
4724 * \brief The remote limit switch device is not present on CAN Bus.
4725 *
4726 * - Default Value: False
4727 *
4728 * Default Rates:
4729 * - CAN: 4.0 Hz
4730 *
4731 * This refreshes and returns a cached StatusSignal object.
4732 *
4733 * \param refresh Whether to refresh the StatusSignal before returning it;
4734 * defaults to true
4735 * \returns StickyFault_MissingHardLimitRemote Status Signal Object
4736 */
4737 StatusSignal<bool> &GetStickyFault_MissingHardLimitRemote(bool refresh = true) final;
4738
4739 /**
4740 * \brief The remote sensor's data is no longer trusted. This can
4741 * happen if the remote sensor disappears from the CAN bus or if the
4742 * remote sensor indicates its data is no longer valid, such as when a
4743 * CANcoder's magnet strength falls into the "red" range.
4744 *
4745 * - Default Value: False
4746 *
4747 * Default Rates:
4748 * - CAN: 4.0 Hz
4749 *
4750 * This refreshes and returns a cached StatusSignal object.
4751 *
4752 * \param refresh Whether to refresh the StatusSignal before returning it;
4753 * defaults to true
4754 * \returns Fault_RemoteSensorDataInvalid Status Signal Object
4755 */
4756 StatusSignal<bool> &GetFault_RemoteSensorDataInvalid(bool refresh = true) final;
4757
4758 /**
4759 * \brief The remote sensor's data is no longer trusted. This can
4760 * happen if the remote sensor disappears from the CAN bus or if the
4761 * remote sensor indicates its data is no longer valid, such as when a
4762 * CANcoder's magnet strength falls into the "red" range.
4763 *
4764 * - Default Value: False
4765 *
4766 * Default Rates:
4767 * - CAN: 4.0 Hz
4768 *
4769 * This refreshes and returns a cached StatusSignal object.
4770 *
4771 * \param refresh Whether to refresh the StatusSignal before returning it;
4772 * defaults to true
4773 * \returns StickyFault_RemoteSensorDataInvalid Status Signal Object
4774 */
4775 StatusSignal<bool> &GetStickyFault_RemoteSensorDataInvalid(bool refresh = true) final;
4776
4777 /**
4778 * \brief The remote sensor used for fusion has fallen out of sync to
4779 * the local sensor. A re-synchronization has occurred, which may
4780 * cause a discontinuity. This typically happens if there is
4781 * significant slop in the mechanism, or if the RotorToSensorRatio
4782 * configuration parameter is incorrect.
4783 *
4784 * - Default Value: False
4785 *
4786 * Default Rates:
4787 * - CAN: 4.0 Hz
4788 *
4789 * This refreshes and returns a cached StatusSignal object.
4790 *
4791 * \param refresh Whether to refresh the StatusSignal before returning it;
4792 * defaults to true
4793 * \returns Fault_FusedSensorOutOfSync Status Signal Object
4794 */
4795 StatusSignal<bool> &GetFault_FusedSensorOutOfSync(bool refresh = true) final;
4796
4797 /**
4798 * \brief The remote sensor used for fusion has fallen out of sync to
4799 * the local sensor. A re-synchronization has occurred, which may
4800 * cause a discontinuity. This typically happens if there is
4801 * significant slop in the mechanism, or if the RotorToSensorRatio
4802 * configuration parameter is incorrect.
4803 *
4804 * - Default Value: False
4805 *
4806 * Default Rates:
4807 * - CAN: 4.0 Hz
4808 *
4809 * This refreshes and returns a cached StatusSignal object.
4810 *
4811 * \param refresh Whether to refresh the StatusSignal before returning it;
4812 * defaults to true
4813 * \returns StickyFault_FusedSensorOutOfSync Status Signal Object
4814 */
4815 StatusSignal<bool> &GetStickyFault_FusedSensorOutOfSync(bool refresh = true) final;
4816
4817 /**
4818 * \brief Stator current limit occured.
4819 *
4820 * - Default Value: False
4821 *
4822 * Default Rates:
4823 * - CAN: 4.0 Hz
4824 *
4825 * This refreshes and returns a cached StatusSignal object.
4826 *
4827 * \param refresh Whether to refresh the StatusSignal before returning it;
4828 * defaults to true
4829 * \returns Fault_StatorCurrLimit Status Signal Object
4830 */
4831 StatusSignal<bool> &GetFault_StatorCurrLimit(bool refresh = true) final;
4832
4833 /**
4834 * \brief Stator current limit occured.
4835 *
4836 * - Default Value: False
4837 *
4838 * Default Rates:
4839 * - CAN: 4.0 Hz
4840 *
4841 * This refreshes and returns a cached StatusSignal object.
4842 *
4843 * \param refresh Whether to refresh the StatusSignal before returning it;
4844 * defaults to true
4845 * \returns StickyFault_StatorCurrLimit Status Signal Object
4846 */
4847 StatusSignal<bool> &GetStickyFault_StatorCurrLimit(bool refresh = true) final;
4848
4849 /**
4850 * \brief Supply current limit occured.
4851 *
4852 * - Default Value: False
4853 *
4854 * Default Rates:
4855 * - CAN: 4.0 Hz
4856 *
4857 * This refreshes and returns a cached StatusSignal object.
4858 *
4859 * \param refresh Whether to refresh the StatusSignal before returning it;
4860 * defaults to true
4861 * \returns Fault_SupplyCurrLimit Status Signal Object
4862 */
4863 StatusSignal<bool> &GetFault_SupplyCurrLimit(bool refresh = true) final;
4864
4865 /**
4866 * \brief Supply current limit occured.
4867 *
4868 * - Default Value: False
4869 *
4870 * Default Rates:
4871 * - CAN: 4.0 Hz
4872 *
4873 * This refreshes and returns a cached StatusSignal object.
4874 *
4875 * \param refresh Whether to refresh the StatusSignal before returning it;
4876 * defaults to true
4877 * \returns StickyFault_SupplyCurrLimit Status Signal Object
4878 */
4879 StatusSignal<bool> &GetStickyFault_SupplyCurrLimit(bool refresh = true) final;
4880
4881 /**
4882 * \brief Using Fused CANcoder feature while unlicensed. Device has
4883 * fallen back to remote CANcoder.
4884 *
4885 * - Default Value: False
4886 *
4887 * Default Rates:
4888 * - CAN: 4.0 Hz
4889 *
4890 * This refreshes and returns a cached StatusSignal object.
4891 *
4892 * \param refresh Whether to refresh the StatusSignal before returning it;
4893 * defaults to true
4894 * \returns Fault_UsingFusedCANcoderWhileUnlicensed Status Signal Object
4895 */
4896 StatusSignal<bool> &GetFault_UsingFusedCANcoderWhileUnlicensed(bool refresh = true) final;
4897
4898 /**
4899 * \brief Using Fused CANcoder feature while unlicensed. Device has
4900 * fallen back to remote CANcoder.
4901 *
4902 * - Default Value: False
4903 *
4904 * Default Rates:
4905 * - CAN: 4.0 Hz
4906 *
4907 * This refreshes and returns a cached StatusSignal object.
4908 *
4909 * \param refresh Whether to refresh the StatusSignal before returning it;
4910 * defaults to true
4911 * \returns StickyFault_UsingFusedCANcoderWhileUnlicensed Status Signal Object
4912 */
4913 StatusSignal<bool> &GetStickyFault_UsingFusedCANcoderWhileUnlicensed(bool refresh = true) final;
4914
4915 /**
4916 * \brief Static brake was momentarily disabled due to excessive
4917 * braking current while disabled.
4918 *
4919 * - Default Value: False
4920 *
4921 * Default Rates:
4922 * - CAN: 4.0 Hz
4923 *
4924 * This refreshes and returns a cached StatusSignal object.
4925 *
4926 * \param refresh Whether to refresh the StatusSignal before returning it;
4927 * defaults to true
4928 * \returns Fault_StaticBrakeDisabled Status Signal Object
4929 */
4930 StatusSignal<bool> &GetFault_StaticBrakeDisabled(bool refresh = true) final;
4931
4932 /**
4933 * \brief Static brake was momentarily disabled due to excessive
4934 * braking current while disabled.
4935 *
4936 * - Default Value: False
4937 *
4938 * Default Rates:
4939 * - CAN: 4.0 Hz
4940 *
4941 * This refreshes and returns a cached StatusSignal object.
4942 *
4943 * \param refresh Whether to refresh the StatusSignal before returning it;
4944 * defaults to true
4945 * \returns StickyFault_StaticBrakeDisabled Status Signal Object
4946 */
4947 StatusSignal<bool> &GetStickyFault_StaticBrakeDisabled(bool refresh = true) final;
4948
4949 /**
4950 * \brief Trips if a major mechanical or ESD event caused a brief loss
4951 * of position data triggering a recovery while not in motion. If the
4952 * event occurs often, inspect for excess axial force or sources of
4953 * ESD at the rotor.
4954 *
4955 * - Default Value: False
4956 *
4957 * Default Rates:
4958 * - CAN: 4.0 Hz
4959 *
4960 * This refreshes and returns a cached StatusSignal object.
4961 *
4962 * \param refresh Whether to refresh the StatusSignal before returning it;
4963 * defaults to true
4964 * \returns Fault_RotorFault1 Status Signal Object
4965 */
4966 StatusSignal<bool> &GetFault_RotorFault1(bool refresh = true) final;
4967
4968 /**
4969 * \brief Trips if a major mechanical or ESD event caused a brief loss
4970 * of position data triggering a recovery while not in motion. If the
4971 * event occurs often, inspect for excess axial force or sources of
4972 * ESD at the rotor.
4973 *
4974 * - Default Value: False
4975 *
4976 * Default Rates:
4977 * - CAN: 4.0 Hz
4978 *
4979 * This refreshes and returns a cached StatusSignal object.
4980 *
4981 * \param refresh Whether to refresh the StatusSignal before returning it;
4982 * defaults to true
4983 * \returns StickyFault_RotorFault1 Status Signal Object
4984 */
4985 StatusSignal<bool> &GetStickyFault_RotorFault1(bool refresh = true) final;
4986
4987 /**
4988 * \brief Trips if a major mechanical or ESD event caused a brief loss
4989 * of position data triggering a recovery while in motion. If the
4990 * event occurs often, inspect for excess axial force or sources of
4991 * ESD at the rotor.
4992 *
4993 * - Default Value: False
4994 *
4995 * Default Rates:
4996 * - CAN: 4.0 Hz
4997 *
4998 * This refreshes and returns a cached StatusSignal object.
4999 *
5000 * \param refresh Whether to refresh the StatusSignal before returning it;
5001 * defaults to true
5002 * \returns Fault_RotorFault2 Status Signal Object
5003 */
5004 StatusSignal<bool> &GetFault_RotorFault2(bool refresh = true) final;
5005
5006 /**
5007 * \brief Trips if a major mechanical or ESD event caused a brief loss
5008 * of position data triggering a recovery while in motion. If the
5009 * event occurs often, inspect for excess axial force or sources of
5010 * ESD at the rotor.
5011 *
5012 * - Default Value: False
5013 *
5014 * Default Rates:
5015 * - CAN: 4.0 Hz
5016 *
5017 * This refreshes and returns a cached StatusSignal object.
5018 *
5019 * \param refresh Whether to refresh the StatusSignal before returning it;
5020 * defaults to true
5021 * \returns StickyFault_RotorFault2 Status Signal Object
5022 */
5023 StatusSignal<bool> &GetStickyFault_RotorFault2(bool refresh = true) final;
5024
5025 /**
5026 * \brief Closed loop proportional component.
5027 *
5028 * \details The portion of the closed loop output that is proportional
5029 * to the error. Alternatively, the kP contribution of the closed loop
5030 * output.
5031 *
5032 * When using differential control, this applies to the average axis.
5033 *
5034 * Default Rates:
5035 * - CAN 2.0: 4.0 Hz
5036 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5037 *
5038 * This refreshes and returns a cached StatusSignal object.
5039 *
5040 * \param refresh Whether to refresh the StatusSignal before returning it;
5041 * defaults to true
5042 * \returns ClosedLoopProportionalOutput Status Signal object
5043 */
5044 StatusSignal<double> &GetClosedLoopProportionalOutput(bool refresh = true) final;
5045
5046 /**
5047 * \brief Closed loop integrated component.
5048 *
5049 * \details The portion of the closed loop output that is proportional
5050 * to the integrated error. Alternatively, the kI contribution of the
5051 * closed loop output.
5052 *
5053 * When using differential control, this applies to the average axis.
5054 *
5055 * Default Rates:
5056 * - CAN 2.0: 4.0 Hz
5057 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5058 *
5059 * This refreshes and returns a cached StatusSignal object.
5060 *
5061 * \param refresh Whether to refresh the StatusSignal before returning it;
5062 * defaults to true
5063 * \returns ClosedLoopIntegratedOutput Status Signal object
5064 */
5065 StatusSignal<double> &GetClosedLoopIntegratedOutput(bool refresh = true) final;
5066
5067 /**
5068 * \brief Feedforward passed by the user.
5069 *
5070 * \details This is the general feedforward that the user provides for
5071 * the closed loop.
5072 *
5073 * When using differential control, this applies to the average axis.
5074 *
5075 * Default Rates:
5076 * - CAN 2.0: 4.0 Hz
5077 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5078 *
5079 * This refreshes and returns a cached StatusSignal object.
5080 *
5081 * \param refresh Whether to refresh the StatusSignal before returning it;
5082 * defaults to true
5083 * \returns ClosedLoopFeedForward Status Signal object
5084 */
5085 StatusSignal<double> &GetClosedLoopFeedForward(bool refresh = true) final;
5086
5087 /**
5088 * \brief Closed loop derivative component.
5089 *
5090 * \details The portion of the closed loop output that is proportional
5091 * to the deriviative of error. Alternatively, the kD contribution of
5092 * the closed loop output.
5093 *
5094 * When using differential control, this applies to the average axis.
5095 *
5096 * Default Rates:
5097 * - CAN 2.0: 4.0 Hz
5098 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5099 *
5100 * This refreshes and returns a cached StatusSignal object.
5101 *
5102 * \param refresh Whether to refresh the StatusSignal before returning it;
5103 * defaults to true
5104 * \returns ClosedLoopDerivativeOutput Status Signal object
5105 */
5106 StatusSignal<double> &GetClosedLoopDerivativeOutput(bool refresh = true) final;
5107
5108 /**
5109 * \brief Closed loop total output.
5110 *
5111 * \details The total output of the closed loop output.
5112 *
5113 * When using differential control, this applies to the average axis.
5114 *
5115 * Default Rates:
5116 * - CAN 2.0: 4.0 Hz
5117 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5118 *
5119 * This refreshes and returns a cached StatusSignal object.
5120 *
5121 * \param refresh Whether to refresh the StatusSignal before returning it;
5122 * defaults to true
5123 * \returns ClosedLoopOutput Status Signal object
5124 */
5125 StatusSignal<double> &GetClosedLoopOutput(bool refresh = true) final;
5126
5127 /**
5128 * \brief Value that the closed loop is targeting.
5129 *
5130 * \details This is the value that the closed loop PID controller
5131 * targets.
5132 *
5133 * When using differential control, this applies to the average axis.
5134 *
5135 * Default Rates:
5136 * - CAN 2.0: 4.0 Hz
5137 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5138 *
5139 * This refreshes and returns a cached StatusSignal object.
5140 *
5141 * \param refresh Whether to refresh the StatusSignal before returning it;
5142 * defaults to true
5143 * \returns ClosedLoopReference Status Signal object
5144 */
5145 StatusSignal<double> &GetClosedLoopReference(bool refresh = true) final;
5146
5147 /**
5148 * \brief Derivative of the target that the closed loop is targeting.
5149 *
5150 * \details This is the change in the closed loop reference. This may
5151 * be used in the feed-forward calculation, the derivative-error, or
5152 * in application of the signage for kS. Typically, this represents
5153 * the target velocity during Motion Magic®.
5154 *
5155 * When using differential control, this applies to the average axis.
5156 *
5157 * Default Rates:
5158 * - CAN 2.0: 4.0 Hz
5159 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5160 *
5161 * This refreshes and returns a cached StatusSignal object.
5162 *
5163 * \param refresh Whether to refresh the StatusSignal before returning it;
5164 * defaults to true
5165 * \returns ClosedLoopReferenceSlope Status Signal object
5166 */
5167 StatusSignal<double> &GetClosedLoopReferenceSlope(bool refresh = true) final;
5168
5169 /**
5170 * \brief The difference between target reference and current
5171 * measurement.
5172 *
5173 * \details This is the value that is treated as the error in the PID
5174 * loop.
5175 *
5176 * When using differential control, this applies to the average axis.
5177 *
5178 * Default Rates:
5179 * - CAN 2.0: 4.0 Hz
5180 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5181 *
5182 * This refreshes and returns a cached StatusSignal object.
5183 *
5184 * \param refresh Whether to refresh the StatusSignal before returning it;
5185 * defaults to true
5186 * \returns ClosedLoopError Status Signal object
5187 */
5188 StatusSignal<double> &GetClosedLoopError(bool refresh = true) final;
5189
5190 /**
5191 * \brief The calculated motor output for differential followers.
5192 *
5193 * \details This is a torque request when using the TorqueCurrentFOC
5194 * control output type, a voltage request when using the Voltage
5195 * control output type, and a duty cycle when using the DutyCycle
5196 * control output type.
5197 *
5198 * Default Rates:
5199 * - CAN 2.0: 100.0 Hz
5200 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5201 *
5202 * This refreshes and returns a cached StatusSignal object.
5203 *
5204 * \param refresh Whether to refresh the StatusSignal before returning it;
5205 * defaults to true
5206 * \returns DifferentialOutput Status Signal object
5207 */
5208 StatusSignal<double> &GetDifferentialOutput(bool refresh = true) final;
5209
5210 /**
5211 * \brief Differential closed loop proportional component.
5212 *
5213 * \details The portion of the differential closed loop output (on the
5214 * difference axis) that is proportional to the error. Alternatively,
5215 * the kP contribution of the closed loop output.
5216 *
5217 * Default Rates:
5218 * - CAN 2.0: 4.0 Hz
5219 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5220 *
5221 * This refreshes and returns a cached StatusSignal object.
5222 *
5223 * \param refresh Whether to refresh the StatusSignal before returning it;
5224 * defaults to true
5225 * \returns DifferentialClosedLoopProportionalOutput Status Signal object
5226 */
5227 StatusSignal<double> &GetDifferentialClosedLoopProportionalOutput(bool refresh = true) final;
5228
5229 /**
5230 * \brief Differential closed loop integrated component.
5231 *
5232 * \details The portion of the differential closed loop output (on the
5233 * difference axis) that is proportional to the integrated error.
5234 * Alternatively, the kI contribution of the closed loop output.
5235 *
5236 * Default Rates:
5237 * - CAN 2.0: 100.0 Hz
5238 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5239 *
5240 * This refreshes and returns a cached StatusSignal object.
5241 *
5242 * \param refresh Whether to refresh the StatusSignal before returning it;
5243 * defaults to true
5244 * \returns DifferentialClosedLoopIntegratedOutput Status Signal object
5245 */
5246 StatusSignal<double> &GetDifferentialClosedLoopIntegratedOutput(bool refresh = true) final;
5247
5248 /**
5249 * \brief Differential Feedforward passed by the user.
5250 *
5251 * \details This is the general feedforward that the user provides for
5252 * the differential closed loop (on the difference axis).
5253 *
5254 * Default Rates:
5255 * - CAN 2.0: 100.0 Hz
5256 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5257 *
5258 * This refreshes and returns a cached StatusSignal object.
5259 *
5260 * \param refresh Whether to refresh the StatusSignal before returning it;
5261 * defaults to true
5262 * \returns DifferentialClosedLoopFeedForward Status Signal object
5263 */
5264 StatusSignal<double> &GetDifferentialClosedLoopFeedForward(bool refresh = true) final;
5265
5266 /**
5267 * \brief Differential closed loop derivative component.
5268 *
5269 * \details The portion of the differential closed loop output (on the
5270 * difference axis) that is proportional to the deriviative of error.
5271 * Alternatively, the kD contribution of the closed loop output.
5272 *
5273 * Default Rates:
5274 * - CAN 2.0: 4.0 Hz
5275 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5276 *
5277 * This refreshes and returns a cached StatusSignal object.
5278 *
5279 * \param refresh Whether to refresh the StatusSignal before returning it;
5280 * defaults to true
5281 * \returns DifferentialClosedLoopDerivativeOutput Status Signal object
5282 */
5283 StatusSignal<double> &GetDifferentialClosedLoopDerivativeOutput(bool refresh = true) final;
5284
5285 /**
5286 * \brief Differential closed loop total output.
5287 *
5288 * \details The total output of the differential closed loop output
5289 * (on the difference axis).
5290 *
5291 * Default Rates:
5292 * - CAN 2.0: 4.0 Hz
5293 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5294 *
5295 * This refreshes and returns a cached StatusSignal object.
5296 *
5297 * \param refresh Whether to refresh the StatusSignal before returning it;
5298 * defaults to true
5299 * \returns DifferentialClosedLoopOutput Status Signal object
5300 */
5301 StatusSignal<double> &GetDifferentialClosedLoopOutput(bool refresh = true) final;
5302
5303 /**
5304 * \brief Value that the differential closed loop is targeting.
5305 *
5306 * \details This is the value that the differential closed loop PID
5307 * controller targets (on the difference axis).
5308 *
5309 * Default Rates:
5310 * - CAN 2.0: 4.0 Hz
5311 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5312 *
5313 * This refreshes and returns a cached StatusSignal object.
5314 *
5315 * \param refresh Whether to refresh the StatusSignal before returning it;
5316 * defaults to true
5317 * \returns DifferentialClosedLoopReference Status Signal object
5318 */
5319 StatusSignal<double> &GetDifferentialClosedLoopReference(bool refresh = true) final;
5320
5321 /**
5322 * \brief Derivative of the target that the differential closed loop
5323 * is targeting.
5324 *
5325 * \details This is the change in the closed loop reference (on the
5326 * difference axis). This may be used in the feed-forward calculation,
5327 * the derivative-error, or in application of the signage for kS.
5328 * Typically, this represents the target velocity during Motion
5329 * Magic®.
5330 *
5331 * Default Rates:
5332 * - CAN 2.0: 4.0 Hz
5333 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5334 *
5335 * This refreshes and returns a cached StatusSignal object.
5336 *
5337 * \param refresh Whether to refresh the StatusSignal before returning it;
5338 * defaults to true
5339 * \returns DifferentialClosedLoopReferenceSlope Status Signal object
5340 */
5341 StatusSignal<double> &GetDifferentialClosedLoopReferenceSlope(bool refresh = true) final;
5342
5343 /**
5344 * \brief The difference between target differential reference and
5345 * current measurement.
5346 *
5347 * \details This is the value that is treated as the error in the
5348 * differential PID loop (on the difference axis).
5349 *
5350 * Default Rates:
5351 * - CAN 2.0: 4.0 Hz
5352 * - CAN FD: 100.0 Hz (TimeSynced with Pro)
5353 *
5354 * This refreshes and returns a cached StatusSignal object.
5355 *
5356 * \param refresh Whether to refresh the StatusSignal before returning it;
5357 * defaults to true
5358 * \returns DifferentialClosedLoopError Status Signal object
5359 */
5360 StatusSignal<double> &GetDifferentialClosedLoopError(bool refresh = true) final;
5361
5362
5363 /**
5364 * \brief Request a specified motor duty cycle.
5365 *
5366 * \details This control mode will output a proportion of the supplied
5367 * voltage which is supplied by the user.
5368 *
5369 * - DutyCycleOut Parameters:
5370 * - Output: Proportion of supply voltage to apply in fractional units between
5371 * -1 and +1
5372 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5373 * which increases peak power by ~15% on supported devices (see
5374 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5375 * commutation.
5376 *
5377 * FOC improves motor performance by leveraging torque (current)
5378 * control. However, this may be inconvenient for applications
5379 * that require specifying duty cycle or voltage.
5380 * CTR-Electronics has developed a hybrid method that combines
5381 * the performances gains of FOC while still allowing
5382 * applications to provide duty cycle or voltage demand. This
5383 * not to be confused with simple sinusoidal control or phase
5384 * voltage control which lacks the performance gains.
5385 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5386 * output is zero (or within deadband). Set to
5387 * false to use the NeutralMode configuration
5388 * setting (default). This flag exists to provide
5389 * the fundamental behavior of this control when
5390 * output is zero, which is to provide 0V to the
5391 * motor.
5392 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5393 * users to use other limit switch sensors connected to
5394 * robot controller. This also allows use of active
5395 * sensors that require external power.
5396 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5397 * users to use other limit switch sensors connected to
5398 * robot controller. This also allows use of active
5399 * sensors that require external power.
5400 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5401 * the LimitForwardMotion and LimitReverseMotion
5402 * parameters, instead allowing motion.
5403 *
5404 * This can be useful on mechanisms such as an
5405 * intake/feeder, where a limit switch stops motion
5406 * while intaking but should be ignored when feeding
5407 * to a shooter.
5408 *
5409 * The hardware limit faults and Forward/ReverseLimit
5410 * signals will still report the values of the limit
5411 * switches regardless of this parameter.
5412 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5413 * allowing motion.
5414 *
5415 * This can be useful when calibrating the zero point
5416 * of a mechanism such as an elevator.
5417 *
5418 * The software limit faults will still report the
5419 * values of the software limits regardless of this
5420 * parameter.
5421 * - UseTimesync: Set to true to delay applying this control request until a
5422 * timesync boundary (requires Phoenix Pro and CANivore). This
5423 * eliminates the impact of nondeterministic network delays in
5424 * exchange for a larger but deterministic control latency.
5425 *
5426 * This requires setting the ControlTimesyncFreqHz config in
5427 * MotorOutputConfigs. Additionally, when this is enabled, the
5428 * UpdateFreqHz of this request should be set to 0 Hz.
5429 *
5430 * \param request Control object to request of the device
5431 * \returns Status code of the request
5432 */
5433 ctre::phoenix::StatusCode SetControl(controls::DutyCycleOut const &request) final;
5434
5435 /**
5436 * \brief Request a specified motor current (field oriented control).
5437 *
5438 * \details This control request will drive the motor to the requested
5439 * motor (stator) current value. This leverages field oriented
5440 * control (FOC), which means greater peak power than what is
5441 * documented. This scales to torque based on Motor's kT constant.
5442 *
5443 * - TorqueCurrentFOC Parameters:
5444 * - Output: Amount of motor current in Amperes
5445 * - MaxAbsDutyCycle: The maximum absolute motor output that can be applied,
5446 * which effectively limits the velocity. For example, 0.50
5447 * means no more than 50% output in either direction. This
5448 * is useful for preventing the motor from spinning to its
5449 * terminal velocity when there is no external torque
5450 * applied unto the rotor. Note this is absolute maximum,
5451 * so the value should be between zero and one.
5452 * - Deadband: Deadband in Amperes. If torque request is within deadband, the
5453 * bridge output is neutral. If deadband is set to zero then there
5454 * is effectively no deadband. Note if deadband is zero, a free
5455 * spinning motor will spin for quite a while as the firmware
5456 * attempts to hold the motor's bemf. If user expects motor to
5457 * cease spinning quickly with a demand of zero, we recommend a
5458 * deadband of one Ampere. This value will be converted to an
5459 * integral value of amps.
5460 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
5461 * zero (or within deadband). Set to false to use
5462 * the NeutralMode configuration setting (default).
5463 * This flag exists to provide the fundamental
5464 * behavior of this control when output is zero,
5465 * which is to provide 0A (zero torque).
5466 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5467 * users to use other limit switch sensors connected to
5468 * robot controller. This also allows use of active
5469 * sensors that require external power.
5470 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5471 * users to use other limit switch sensors connected to
5472 * robot controller. This also allows use of active
5473 * sensors that require external power.
5474 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5475 * the LimitForwardMotion and LimitReverseMotion
5476 * parameters, instead allowing motion.
5477 *
5478 * This can be useful on mechanisms such as an
5479 * intake/feeder, where a limit switch stops motion
5480 * while intaking but should be ignored when feeding
5481 * to a shooter.
5482 *
5483 * The hardware limit faults and Forward/ReverseLimit
5484 * signals will still report the values of the limit
5485 * switches regardless of this parameter.
5486 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5487 * allowing motion.
5488 *
5489 * This can be useful when calibrating the zero point
5490 * of a mechanism such as an elevator.
5491 *
5492 * The software limit faults will still report the
5493 * values of the software limits regardless of this
5494 * parameter.
5495 * - UseTimesync: Set to true to delay applying this control request until a
5496 * timesync boundary (requires Phoenix Pro and CANivore). This
5497 * eliminates the impact of nondeterministic network delays in
5498 * exchange for a larger but deterministic control latency.
5499 *
5500 * This requires setting the ControlTimesyncFreqHz config in
5501 * MotorOutputConfigs. Additionally, when this is enabled, the
5502 * UpdateFreqHz of this request should be set to 0 Hz.
5503 *
5504 * \param request Control object to request of the device
5505 * \returns Status code of the request
5506 */
5507 ctre::phoenix::StatusCode SetControl(controls::TorqueCurrentFOC const &request) final;
5508
5509 /**
5510 * \brief Request a specified voltage.
5511 *
5512 * \details This control mode will attempt to apply the specified
5513 * voltage to the motor. If the supply voltage is below the requested
5514 * voltage, the motor controller will output the supply voltage.
5515 *
5516 * - VoltageOut Parameters:
5517 * - Output: Voltage to attempt to drive at
5518 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5519 * which increases peak power by ~15% on supported devices (see
5520 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5521 * commutation.
5522 *
5523 * FOC improves motor performance by leveraging torque (current)
5524 * control. However, this may be inconvenient for applications
5525 * that require specifying duty cycle or voltage.
5526 * CTR-Electronics has developed a hybrid method that combines
5527 * the performances gains of FOC while still allowing
5528 * applications to provide duty cycle or voltage demand. This
5529 * not to be confused with simple sinusoidal control or phase
5530 * voltage control which lacks the performance gains.
5531 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5532 * output is zero (or within deadband). Set to
5533 * false to use the NeutralMode configuration
5534 * setting (default). This flag exists to provide
5535 * the fundamental behavior of this control when
5536 * output is zero, which is to provide 0V to the
5537 * motor.
5538 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5539 * users to use other limit switch sensors connected to
5540 * robot controller. This also allows use of active
5541 * sensors that require external power.
5542 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5543 * users to use other limit switch sensors connected to
5544 * robot controller. This also allows use of active
5545 * sensors that require external power.
5546 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5547 * the LimitForwardMotion and LimitReverseMotion
5548 * parameters, instead allowing motion.
5549 *
5550 * This can be useful on mechanisms such as an
5551 * intake/feeder, where a limit switch stops motion
5552 * while intaking but should be ignored when feeding
5553 * to a shooter.
5554 *
5555 * The hardware limit faults and Forward/ReverseLimit
5556 * signals will still report the values of the limit
5557 * switches regardless of this parameter.
5558 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5559 * allowing motion.
5560 *
5561 * This can be useful when calibrating the zero point
5562 * of a mechanism such as an elevator.
5563 *
5564 * The software limit faults will still report the
5565 * values of the software limits regardless of this
5566 * parameter.
5567 * - UseTimesync: Set to true to delay applying this control request until a
5568 * timesync boundary (requires Phoenix Pro and CANivore). This
5569 * eliminates the impact of nondeterministic network delays in
5570 * exchange for a larger but deterministic control latency.
5571 *
5572 * This requires setting the ControlTimesyncFreqHz config in
5573 * MotorOutputConfigs. Additionally, when this is enabled, the
5574 * UpdateFreqHz of this request should be set to 0 Hz.
5575 *
5576 * \param request Control object to request of the device
5577 * \returns Status code of the request
5578 */
5579 ctre::phoenix::StatusCode SetControl(controls::VoltageOut const &request) final;
5580
5581 /**
5582 * \brief Request PID to target position with duty cycle feedforward.
5583 *
5584 * \details This control mode will set the motor's position setpoint
5585 * to the position specified by the user. In addition, it will apply
5586 * an additional duty cycle as an arbitrary feedforward value.
5587 *
5588 * - PositionDutyCycle Parameters:
5589 * - Position: Position to drive toward in rotations.
5590 * - Velocity: Velocity to drive toward in rotations per second. This is
5591 * typically used for motion profiles generated by the robot
5592 * program.
5593 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5594 * which increases peak power by ~15% on supported devices (see
5595 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5596 * commutation.
5597 *
5598 * FOC improves motor performance by leveraging torque (current)
5599 * control. However, this may be inconvenient for applications
5600 * that require specifying duty cycle or voltage.
5601 * CTR-Electronics has developed a hybrid method that combines
5602 * the performances gains of FOC while still allowing
5603 * applications to provide duty cycle or voltage demand. This
5604 * not to be confused with simple sinusoidal control or phase
5605 * voltage control which lacks the performance gains.
5606 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
5607 * This is added to the output of the onboard feedforward
5608 * terms.
5609 * - Slot: Select which gains are applied by selecting the slot. Use the
5610 * configuration api to set the gain values for the selected slot
5611 * before enabling this feature. Slot must be within [0,2].
5612 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5613 * output is zero (or within deadband). Set to
5614 * false to use the NeutralMode configuration
5615 * setting (default). This flag exists to provide
5616 * the fundamental behavior of this control when
5617 * output is zero, which is to provide 0V to the
5618 * motor.
5619 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5620 * users to use other limit switch sensors connected to
5621 * robot controller. This also allows use of active
5622 * sensors that require external power.
5623 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5624 * users to use other limit switch sensors connected to
5625 * robot controller. This also allows use of active
5626 * sensors that require external power.
5627 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5628 * the LimitForwardMotion and LimitReverseMotion
5629 * parameters, instead allowing motion.
5630 *
5631 * This can be useful on mechanisms such as an
5632 * intake/feeder, where a limit switch stops motion
5633 * while intaking but should be ignored when feeding
5634 * to a shooter.
5635 *
5636 * The hardware limit faults and Forward/ReverseLimit
5637 * signals will still report the values of the limit
5638 * switches regardless of this parameter.
5639 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5640 * allowing motion.
5641 *
5642 * This can be useful when calibrating the zero point
5643 * of a mechanism such as an elevator.
5644 *
5645 * The software limit faults will still report the
5646 * values of the software limits regardless of this
5647 * parameter.
5648 * - UseTimesync: Set to true to delay applying this control request until a
5649 * timesync boundary (requires Phoenix Pro and CANivore). This
5650 * eliminates the impact of nondeterministic network delays in
5651 * exchange for a larger but deterministic control latency.
5652 *
5653 * This requires setting the ControlTimesyncFreqHz config in
5654 * MotorOutputConfigs. Additionally, when this is enabled, the
5655 * UpdateFreqHz of this request should be set to 0 Hz.
5656 *
5657 * \param request Control object to request of the device
5658 * \returns Status code of the request
5659 */
5660 ctre::phoenix::StatusCode SetControl(controls::PositionDutyCycle const &request) final;
5661
5662 /**
5663 * \brief Request PID to target position with voltage feedforward
5664 *
5665 * \details This control mode will set the motor's position setpoint
5666 * to the position specified by the user. In addition, it will apply
5667 * an additional voltage as an arbitrary feedforward value.
5668 *
5669 * - PositionVoltage Parameters:
5670 * - Position: Position to drive toward in rotations.
5671 * - Velocity: Velocity to drive toward in rotations per second. This is
5672 * typically used for motion profiles generated by the robot
5673 * program.
5674 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5675 * which increases peak power by ~15% on supported devices (see
5676 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5677 * commutation.
5678 *
5679 * FOC improves motor performance by leveraging torque (current)
5680 * control. However, this may be inconvenient for applications
5681 * that require specifying duty cycle or voltage.
5682 * CTR-Electronics has developed a hybrid method that combines
5683 * the performances gains of FOC while still allowing
5684 * applications to provide duty cycle or voltage demand. This
5685 * not to be confused with simple sinusoidal control or phase
5686 * voltage control which lacks the performance gains.
5687 * - FeedForward: Feedforward to apply in volts. This is added to the output
5688 * of the onboard feedforward terms.
5689 * - Slot: Select which gains are applied by selecting the slot. Use the
5690 * configuration api to set the gain values for the selected slot
5691 * before enabling this feature. Slot must be within [0,2].
5692 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5693 * output is zero (or within deadband). Set to
5694 * false to use the NeutralMode configuration
5695 * setting (default). This flag exists to provide
5696 * the fundamental behavior of this control when
5697 * output is zero, which is to provide 0V to the
5698 * motor.
5699 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5700 * users to use other limit switch sensors connected to
5701 * robot controller. This also allows use of active
5702 * sensors that require external power.
5703 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5704 * users to use other limit switch sensors connected to
5705 * robot controller. This also allows use of active
5706 * sensors that require external power.
5707 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5708 * the LimitForwardMotion and LimitReverseMotion
5709 * parameters, instead allowing motion.
5710 *
5711 * This can be useful on mechanisms such as an
5712 * intake/feeder, where a limit switch stops motion
5713 * while intaking but should be ignored when feeding
5714 * to a shooter.
5715 *
5716 * The hardware limit faults and Forward/ReverseLimit
5717 * signals will still report the values of the limit
5718 * switches regardless of this parameter.
5719 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5720 * allowing motion.
5721 *
5722 * This can be useful when calibrating the zero point
5723 * of a mechanism such as an elevator.
5724 *
5725 * The software limit faults will still report the
5726 * values of the software limits regardless of this
5727 * parameter.
5728 * - UseTimesync: Set to true to delay applying this control request until a
5729 * timesync boundary (requires Phoenix Pro and CANivore). This
5730 * eliminates the impact of nondeterministic network delays in
5731 * exchange for a larger but deterministic control latency.
5732 *
5733 * This requires setting the ControlTimesyncFreqHz config in
5734 * MotorOutputConfigs. Additionally, when this is enabled, the
5735 * UpdateFreqHz of this request should be set to 0 Hz.
5736 *
5737 * \param request Control object to request of the device
5738 * \returns Status code of the request
5739 */
5740 ctre::phoenix::StatusCode SetControl(controls::PositionVoltage const &request) final;
5741
5742 /**
5743 * \brief Request PID to target position with torque current
5744 * feedforward.
5745 *
5746 * \details This control mode will set the motor's position setpoint
5747 * to the position specified by the user. In addition, it will apply
5748 * an additional torque current as an arbitrary feedforward value.
5749 *
5750 * - PositionTorqueCurrentFOC Parameters:
5751 * - Position: Position to drive toward in rotations.
5752 * - Velocity: Velocity to drive toward in rotations per second. This is
5753 * typically used for motion profiles generated by the robot
5754 * program.
5755 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
5756 * added to the output of the onboard feedforward terms.
5757 *
5758 * User can use motor's kT to scale Newton-meter to Amperes.
5759 * - Slot: Select which gains are applied by selecting the slot. Use the
5760 * configuration api to set the gain values for the selected slot
5761 * before enabling this feature. Slot must be within [0,2].
5762 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
5763 * zero (or within deadband). Set to false to use
5764 * the NeutralMode configuration setting (default).
5765 * This flag exists to provide the fundamental
5766 * behavior of this control when output is zero,
5767 * which is to provide 0A (zero torque).
5768 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5769 * users to use other limit switch sensors connected to
5770 * robot controller. This also allows use of active
5771 * sensors that require external power.
5772 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5773 * users to use other limit switch sensors connected to
5774 * robot controller. This also allows use of active
5775 * sensors that require external power.
5776 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5777 * the LimitForwardMotion and LimitReverseMotion
5778 * parameters, instead allowing motion.
5779 *
5780 * This can be useful on mechanisms such as an
5781 * intake/feeder, where a limit switch stops motion
5782 * while intaking but should be ignored when feeding
5783 * to a shooter.
5784 *
5785 * The hardware limit faults and Forward/ReverseLimit
5786 * signals will still report the values of the limit
5787 * switches regardless of this parameter.
5788 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5789 * allowing motion.
5790 *
5791 * This can be useful when calibrating the zero point
5792 * of a mechanism such as an elevator.
5793 *
5794 * The software limit faults will still report the
5795 * values of the software limits regardless of this
5796 * parameter.
5797 * - UseTimesync: Set to true to delay applying this control request until a
5798 * timesync boundary (requires Phoenix Pro and CANivore). This
5799 * eliminates the impact of nondeterministic network delays in
5800 * exchange for a larger but deterministic control latency.
5801 *
5802 * This requires setting the ControlTimesyncFreqHz config in
5803 * MotorOutputConfigs. Additionally, when this is enabled, the
5804 * UpdateFreqHz of this request should be set to 0 Hz.
5805 *
5806 * \param request Control object to request of the device
5807 * \returns Status code of the request
5808 */
5809 ctre::phoenix::StatusCode SetControl(controls::PositionTorqueCurrentFOC const &request) final;
5810
5811 /**
5812 * \brief Request PID to target velocity with duty cycle feedforward.
5813 *
5814 * \details This control mode will set the motor's velocity setpoint
5815 * to the velocity specified by the user. In addition, it will apply
5816 * an additional voltage as an arbitrary feedforward value.
5817 *
5818 * - VelocityDutyCycle Parameters:
5819 * - Velocity: Velocity to drive toward in rotations per second.
5820 * - Acceleration: Acceleration to drive toward in rotations per second
5821 * squared. This is typically used for motion profiles
5822 * generated by the robot program.
5823 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5824 * which increases peak power by ~15% on supported devices (see
5825 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5826 * commutation.
5827 *
5828 * FOC improves motor performance by leveraging torque (current)
5829 * control. However, this may be inconvenient for applications
5830 * that require specifying duty cycle or voltage.
5831 * CTR-Electronics has developed a hybrid method that combines
5832 * the performances gains of FOC while still allowing
5833 * applications to provide duty cycle or voltage demand. This
5834 * not to be confused with simple sinusoidal control or phase
5835 * voltage control which lacks the performance gains.
5836 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
5837 * This is added to the output of the onboard feedforward
5838 * terms.
5839 * - Slot: Select which gains are applied by selecting the slot. Use the
5840 * configuration api to set the gain values for the selected slot
5841 * before enabling this feature. Slot must be within [0,2].
5842 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5843 * output is zero (or within deadband). Set to
5844 * false to use the NeutralMode configuration
5845 * setting (default). This flag exists to provide
5846 * the fundamental behavior of this control when
5847 * output is zero, which is to provide 0V to the
5848 * motor.
5849 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5850 * users to use other limit switch sensors connected to
5851 * robot controller. This also allows use of active
5852 * sensors that require external power.
5853 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5854 * users to use other limit switch sensors connected to
5855 * robot controller. This also allows use of active
5856 * sensors that require external power.
5857 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5858 * the LimitForwardMotion and LimitReverseMotion
5859 * parameters, instead allowing motion.
5860 *
5861 * This can be useful on mechanisms such as an
5862 * intake/feeder, where a limit switch stops motion
5863 * while intaking but should be ignored when feeding
5864 * to a shooter.
5865 *
5866 * The hardware limit faults and Forward/ReverseLimit
5867 * signals will still report the values of the limit
5868 * switches regardless of this parameter.
5869 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5870 * allowing motion.
5871 *
5872 * This can be useful when calibrating the zero point
5873 * of a mechanism such as an elevator.
5874 *
5875 * The software limit faults will still report the
5876 * values of the software limits regardless of this
5877 * parameter.
5878 * - UseTimesync: Set to true to delay applying this control request until a
5879 * timesync boundary (requires Phoenix Pro and CANivore). This
5880 * eliminates the impact of nondeterministic network delays in
5881 * exchange for a larger but deterministic control latency.
5882 *
5883 * This requires setting the ControlTimesyncFreqHz config in
5884 * MotorOutputConfigs. Additionally, when this is enabled, the
5885 * UpdateFreqHz of this request should be set to 0 Hz.
5886 *
5887 * \param request Control object to request of the device
5888 * \returns Status code of the request
5889 */
5890 ctre::phoenix::StatusCode SetControl(controls::VelocityDutyCycle const &request) final;
5891
5892 /**
5893 * \brief Request PID to target velocity with voltage feedforward.
5894 *
5895 * \details This control mode will set the motor's velocity setpoint
5896 * to the velocity specified by the user. In addition, it will apply
5897 * an additional voltage as an arbitrary feedforward value.
5898 *
5899 * - VelocityVoltage Parameters:
5900 * - Velocity: Velocity to drive toward in rotations per second.
5901 * - Acceleration: Acceleration to drive toward in rotations per second
5902 * squared. This is typically used for motion profiles
5903 * generated by the robot program.
5904 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
5905 * which increases peak power by ~15% on supported devices (see
5906 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
5907 * commutation.
5908 *
5909 * FOC improves motor performance by leveraging torque (current)
5910 * control. However, this may be inconvenient for applications
5911 * that require specifying duty cycle or voltage.
5912 * CTR-Electronics has developed a hybrid method that combines
5913 * the performances gains of FOC while still allowing
5914 * applications to provide duty cycle or voltage demand. This
5915 * not to be confused with simple sinusoidal control or phase
5916 * voltage control which lacks the performance gains.
5917 * - FeedForward: Feedforward to apply in volts This is added to the output of
5918 * the onboard feedforward terms.
5919 * - Slot: Select which gains are applied by selecting the slot. Use the
5920 * configuration api to set the gain values for the selected slot
5921 * before enabling this feature. Slot must be within [0,2].
5922 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
5923 * output is zero (or within deadband). Set to
5924 * false to use the NeutralMode configuration
5925 * setting (default). This flag exists to provide
5926 * the fundamental behavior of this control when
5927 * output is zero, which is to provide 0V to the
5928 * motor.
5929 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5930 * users to use other limit switch sensors connected to
5931 * robot controller. This also allows use of active
5932 * sensors that require external power.
5933 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
5934 * users to use other limit switch sensors connected to
5935 * robot controller. This also allows use of active
5936 * sensors that require external power.
5937 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
5938 * the LimitForwardMotion and LimitReverseMotion
5939 * parameters, instead allowing motion.
5940 *
5941 * This can be useful on mechanisms such as an
5942 * intake/feeder, where a limit switch stops motion
5943 * while intaking but should be ignored when feeding
5944 * to a shooter.
5945 *
5946 * The hardware limit faults and Forward/ReverseLimit
5947 * signals will still report the values of the limit
5948 * switches regardless of this parameter.
5949 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
5950 * allowing motion.
5951 *
5952 * This can be useful when calibrating the zero point
5953 * of a mechanism such as an elevator.
5954 *
5955 * The software limit faults will still report the
5956 * values of the software limits regardless of this
5957 * parameter.
5958 * - UseTimesync: Set to true to delay applying this control request until a
5959 * timesync boundary (requires Phoenix Pro and CANivore). This
5960 * eliminates the impact of nondeterministic network delays in
5961 * exchange for a larger but deterministic control latency.
5962 *
5963 * This requires setting the ControlTimesyncFreqHz config in
5964 * MotorOutputConfigs. Additionally, when this is enabled, the
5965 * UpdateFreqHz of this request should be set to 0 Hz.
5966 *
5967 * \param request Control object to request of the device
5968 * \returns Status code of the request
5969 */
5970 ctre::phoenix::StatusCode SetControl(controls::VelocityVoltage const &request) final;
5971
5972 /**
5973 * \brief Request PID to target velocity with torque current
5974 * feedforward.
5975 *
5976 * \details This control mode will set the motor's velocity setpoint
5977 * to the velocity specified by the user. In addition, it will apply
5978 * an additional torque current as an arbitrary feedforward value.
5979 *
5980 * - VelocityTorqueCurrentFOC Parameters:
5981 * - Velocity: Velocity to drive toward in rotations per second.
5982 * - Acceleration: Acceleration to drive toward in rotations per second
5983 * squared. This is typically used for motion profiles
5984 * generated by the robot program.
5985 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
5986 * added to the output of the onboard feedforward terms.
5987 *
5988 * User can use motor's kT to scale Newton-meter to Amperes.
5989 * - Slot: Select which gains are applied by selecting the slot. Use the
5990 * configuration api to set the gain values for the selected slot
5991 * before enabling this feature. Slot must be within [0,2].
5992 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
5993 * zero (or within deadband). Set to false to use
5994 * the NeutralMode configuration setting (default).
5995 * This flag exists to provide the fundamental
5996 * behavior of this control when output is zero,
5997 * which is to provide 0A (zero torque).
5998 * - LimitForwardMotion: Set to true to force forward limiting. This allows
5999 * users to use other limit switch sensors connected to
6000 * robot controller. This also allows use of active
6001 * sensors that require external power.
6002 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6003 * users to use other limit switch sensors connected to
6004 * robot controller. This also allows use of active
6005 * sensors that require external power.
6006 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6007 * the LimitForwardMotion and LimitReverseMotion
6008 * parameters, instead allowing motion.
6009 *
6010 * This can be useful on mechanisms such as an
6011 * intake/feeder, where a limit switch stops motion
6012 * while intaking but should be ignored when feeding
6013 * to a shooter.
6014 *
6015 * The hardware limit faults and Forward/ReverseLimit
6016 * signals will still report the values of the limit
6017 * switches regardless of this parameter.
6018 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6019 * allowing motion.
6020 *
6021 * This can be useful when calibrating the zero point
6022 * of a mechanism such as an elevator.
6023 *
6024 * The software limit faults will still report the
6025 * values of the software limits regardless of this
6026 * parameter.
6027 * - UseTimesync: Set to true to delay applying this control request until a
6028 * timesync boundary (requires Phoenix Pro and CANivore). This
6029 * eliminates the impact of nondeterministic network delays in
6030 * exchange for a larger but deterministic control latency.
6031 *
6032 * This requires setting the ControlTimesyncFreqHz config in
6033 * MotorOutputConfigs. Additionally, when this is enabled, the
6034 * UpdateFreqHz of this request should be set to 0 Hz.
6035 *
6036 * \param request Control object to request of the device
6037 * \returns Status code of the request
6038 */
6039 ctre::phoenix::StatusCode SetControl(controls::VelocityTorqueCurrentFOC const &request) final;
6040
6041 /**
6042 * \brief Requests Motion Magic® to target a final position using a
6043 * motion profile. Users can optionally provide a duty cycle
6044 * feedforward.
6045 *
6046 * \details Motion Magic® produces a motion profile in real-time while
6047 * attempting to honor the Cruise Velocity, Acceleration, and
6048 * (optional) Jerk specified via the Motion Magic® configuration
6049 * values. This control mode does not use the Expo_kV or Expo_kA
6050 * configs.
6051 *
6052 * Target position can be changed on-the-fly and Motion Magic® will do
6053 * its best to adjust the profile. This control mode is duty cycle
6054 * based, so relevant closed-loop gains will use fractional duty cycle
6055 * for the numerator: +1.0 represents full forward output.
6056 *
6057 * - MotionMagicDutyCycle Parameters:
6058 * - Position: Position to drive toward in rotations.
6059 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6060 * which increases peak power by ~15% on supported devices (see
6061 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6062 * commutation.
6063 *
6064 * FOC improves motor performance by leveraging torque (current)
6065 * control. However, this may be inconvenient for applications
6066 * that require specifying duty cycle or voltage.
6067 * CTR-Electronics has developed a hybrid method that combines
6068 * the performances gains of FOC while still allowing
6069 * applications to provide duty cycle or voltage demand. This
6070 * not to be confused with simple sinusoidal control or phase
6071 * voltage control which lacks the performance gains.
6072 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
6073 * This is added to the output of the onboard feedforward
6074 * terms.
6075 * - Slot: Select which gains are applied by selecting the slot. Use the
6076 * configuration api to set the gain values for the selected slot
6077 * before enabling this feature. Slot must be within [0,2].
6078 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6079 * output is zero (or within deadband). Set to
6080 * false to use the NeutralMode configuration
6081 * setting (default). This flag exists to provide
6082 * the fundamental behavior of this control when
6083 * output is zero, which is to provide 0V to the
6084 * motor.
6085 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6086 * users to use other limit switch sensors connected to
6087 * robot controller. This also allows use of active
6088 * sensors that require external power.
6089 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6090 * users to use other limit switch sensors connected to
6091 * robot controller. This also allows use of active
6092 * sensors that require external power.
6093 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6094 * the LimitForwardMotion and LimitReverseMotion
6095 * parameters, instead allowing motion.
6096 *
6097 * This can be useful on mechanisms such as an
6098 * intake/feeder, where a limit switch stops motion
6099 * while intaking but should be ignored when feeding
6100 * to a shooter.
6101 *
6102 * The hardware limit faults and Forward/ReverseLimit
6103 * signals will still report the values of the limit
6104 * switches regardless of this parameter.
6105 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6106 * allowing motion.
6107 *
6108 * This can be useful when calibrating the zero point
6109 * of a mechanism such as an elevator.
6110 *
6111 * The software limit faults will still report the
6112 * values of the software limits regardless of this
6113 * parameter.
6114 * - UseTimesync: Set to true to delay applying this control request until a
6115 * timesync boundary (requires Phoenix Pro and CANivore). This
6116 * eliminates the impact of nondeterministic network delays in
6117 * exchange for a larger but deterministic control latency.
6118 *
6119 * This requires setting the ControlTimesyncFreqHz config in
6120 * MotorOutputConfigs. Additionally, when this is enabled, the
6121 * UpdateFreqHz of this request should be set to 0 Hz.
6122 *
6123 * \param request Control object to request of the device
6124 * \returns Status code of the request
6125 */
6126 ctre::phoenix::StatusCode SetControl(controls::MotionMagicDutyCycle const &request) final;
6127
6128 /**
6129 * \brief Requests Motion Magic® to target a final position using a
6130 * motion profile. Users can optionally provide a voltage
6131 * feedforward.
6132 *
6133 * \details Motion Magic® produces a motion profile in real-time while
6134 * attempting to honor the Cruise Velocity, Acceleration, and
6135 * (optional) Jerk specified via the Motion Magic® configuration
6136 * values. This control mode does not use the Expo_kV or Expo_kA
6137 * configs.
6138 *
6139 * Target position can be changed on-the-fly and Motion Magic® will do
6140 * its best to adjust the profile. This control mode is
6141 * voltage-based, so relevant closed-loop gains will use Volts for the
6142 * numerator.
6143 *
6144 * - MotionMagicVoltage Parameters:
6145 * - Position: Position to drive toward in rotations.
6146 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6147 * which increases peak power by ~15% on supported devices (see
6148 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6149 * commutation.
6150 *
6151 * FOC improves motor performance by leveraging torque (current)
6152 * control. However, this may be inconvenient for applications
6153 * that require specifying duty cycle or voltage.
6154 * CTR-Electronics has developed a hybrid method that combines
6155 * the performances gains of FOC while still allowing
6156 * applications to provide duty cycle or voltage demand. This
6157 * not to be confused with simple sinusoidal control or phase
6158 * voltage control which lacks the performance gains.
6159 * - FeedForward: Feedforward to apply in volts. This is added to the output
6160 * of the onboard feedforward terms.
6161 * - Slot: Select which gains are applied by selecting the slot. Use the
6162 * configuration api to set the gain values for the selected slot
6163 * before enabling this feature. Slot must be within [0,2].
6164 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6165 * output is zero (or within deadband). Set to
6166 * false to use the NeutralMode configuration
6167 * setting (default). This flag exists to provide
6168 * the fundamental behavior of this control when
6169 * output is zero, which is to provide 0V to the
6170 * motor.
6171 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6172 * users to use other limit switch sensors connected to
6173 * robot controller. This also allows use of active
6174 * sensors that require external power.
6175 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6176 * users to use other limit switch sensors connected to
6177 * robot controller. This also allows use of active
6178 * sensors that require external power.
6179 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6180 * the LimitForwardMotion and LimitReverseMotion
6181 * parameters, instead allowing motion.
6182 *
6183 * This can be useful on mechanisms such as an
6184 * intake/feeder, where a limit switch stops motion
6185 * while intaking but should be ignored when feeding
6186 * to a shooter.
6187 *
6188 * The hardware limit faults and Forward/ReverseLimit
6189 * signals will still report the values of the limit
6190 * switches regardless of this parameter.
6191 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6192 * allowing motion.
6193 *
6194 * This can be useful when calibrating the zero point
6195 * of a mechanism such as an elevator.
6196 *
6197 * The software limit faults will still report the
6198 * values of the software limits regardless of this
6199 * parameter.
6200 * - UseTimesync: Set to true to delay applying this control request until a
6201 * timesync boundary (requires Phoenix Pro and CANivore). This
6202 * eliminates the impact of nondeterministic network delays in
6203 * exchange for a larger but deterministic control latency.
6204 *
6205 * This requires setting the ControlTimesyncFreqHz config in
6206 * MotorOutputConfigs. Additionally, when this is enabled, the
6207 * UpdateFreqHz of this request should be set to 0 Hz.
6208 *
6209 * \param request Control object to request of the device
6210 * \returns Status code of the request
6211 */
6212 ctre::phoenix::StatusCode SetControl(controls::MotionMagicVoltage const &request) final;
6213
6214 /**
6215 * \brief Requests Motion Magic® to target a final position using a
6216 * motion profile. Users can optionally provide a torque current
6217 * feedforward.
6218 *
6219 * \details Motion Magic® produces a motion profile in real-time while
6220 * attempting to honor the Cruise Velocity, Acceleration, and
6221 * (optional) Jerk specified via the Motion Magic® configuration
6222 * values. This control mode does not use the Expo_kV or Expo_kA
6223 * configs.
6224 *
6225 * Target position can be changed on-the-fly and Motion Magic® will do
6226 * its best to adjust the profile. This control mode is based on
6227 * torque current, so relevant closed-loop gains will use Amperes for
6228 * the numerator.
6229 *
6230 * - MotionMagicTorqueCurrentFOC Parameters:
6231 * - Position: Position to drive toward in rotations.
6232 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
6233 * added to the output of the onboard feedforward terms.
6234 *
6235 * User can use motor's kT to scale Newton-meter to Amperes.
6236 * - Slot: Select which gains are applied by selecting the slot. Use the
6237 * configuration api to set the gain values for the selected slot
6238 * before enabling this feature. Slot must be within [0,2].
6239 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
6240 * zero (or within deadband). Set to false to use
6241 * the NeutralMode configuration setting (default).
6242 * This flag exists to provide the fundamental
6243 * behavior of this control when output is zero,
6244 * which is to provide 0A (zero torque).
6245 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6246 * users to use other limit switch sensors connected to
6247 * robot controller. This also allows use of active
6248 * sensors that require external power.
6249 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6250 * users to use other limit switch sensors connected to
6251 * robot controller. This also allows use of active
6252 * sensors that require external power.
6253 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6254 * the LimitForwardMotion and LimitReverseMotion
6255 * parameters, instead allowing motion.
6256 *
6257 * This can be useful on mechanisms such as an
6258 * intake/feeder, where a limit switch stops motion
6259 * while intaking but should be ignored when feeding
6260 * to a shooter.
6261 *
6262 * The hardware limit faults and Forward/ReverseLimit
6263 * signals will still report the values of the limit
6264 * switches regardless of this parameter.
6265 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6266 * allowing motion.
6267 *
6268 * This can be useful when calibrating the zero point
6269 * of a mechanism such as an elevator.
6270 *
6271 * The software limit faults will still report the
6272 * values of the software limits regardless of this
6273 * parameter.
6274 * - UseTimesync: Set to true to delay applying this control request until a
6275 * timesync boundary (requires Phoenix Pro and CANivore). This
6276 * eliminates the impact of nondeterministic network delays in
6277 * exchange for a larger but deterministic control latency.
6278 *
6279 * This requires setting the ControlTimesyncFreqHz config in
6280 * MotorOutputConfigs. Additionally, when this is enabled, the
6281 * UpdateFreqHz of this request should be set to 0 Hz.
6282 *
6283 * \param request Control object to request of the device
6284 * \returns Status code of the request
6285 */
6286 ctre::phoenix::StatusCode SetControl(controls::MotionMagicTorqueCurrentFOC const &request) final;
6287
6288 /**
6289 * \brief Request a specified motor duty cycle with a differential
6290 * position closed-loop.
6291 *
6292 * \details This control mode will output a proportion of the supplied
6293 * voltage which is supplied by the user. It will also set the motor's
6294 * differential position setpoint to the specified position.
6295 *
6296 * - DifferentialDutyCycle Parameters:
6297 * - AverageOutput: Proportion of supply voltage to apply on the Average axis
6298 * in fractional units between -1 and +1.
6299 * - DifferentialPosition: Differential position to drive towards in
6300 * rotations.
6301 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6302 * which increases peak power by ~15% on supported devices (see
6303 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6304 * commutation.
6305 *
6306 * FOC improves motor performance by leveraging torque (current)
6307 * control. However, this may be inconvenient for applications
6308 * that require specifying duty cycle or voltage.
6309 * CTR-Electronics has developed a hybrid method that combines
6310 * the performances gains of FOC while still allowing
6311 * applications to provide duty cycle or voltage demand. This
6312 * not to be confused with simple sinusoidal control or phase
6313 * voltage control which lacks the performance gains.
6314 * - DifferentialSlot: Select which gains are applied to the differential
6315 * controller by selecting the slot. Use the
6316 * configuration api to set the gain values for the
6317 * selected slot before enabling this feature. Slot must
6318 * be within [0,2].
6319 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6320 * output is zero (or within deadband). Set to
6321 * false to use the NeutralMode configuration
6322 * setting (default). This flag exists to provide
6323 * the fundamental behavior of this control when
6324 * output is zero, which is to provide 0V to the
6325 * motor.
6326 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6327 * users to use other limit switch sensors connected to
6328 * robot controller. This also allows use of active
6329 * sensors that require external power.
6330 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6331 * users to use other limit switch sensors connected to
6332 * robot controller. This also allows use of active
6333 * sensors that require external power.
6334 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6335 * the LimitForwardMotion and LimitReverseMotion
6336 * parameters, instead allowing motion.
6337 *
6338 * This can be useful on mechanisms such as an
6339 * intake/feeder, where a limit switch stops motion
6340 * while intaking but should be ignored when feeding
6341 * to a shooter.
6342 *
6343 * The hardware limit faults and Forward/ReverseLimit
6344 * signals will still report the values of the limit
6345 * switches regardless of this parameter.
6346 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6347 * allowing motion.
6348 *
6349 * This can be useful when calibrating the zero point
6350 * of a mechanism such as an elevator.
6351 *
6352 * The software limit faults will still report the
6353 * values of the software limits regardless of this
6354 * parameter.
6355 * - UseTimesync: Set to true to delay applying this control request until a
6356 * timesync boundary (requires Phoenix Pro and CANivore). This
6357 * eliminates the impact of nondeterministic network delays in
6358 * exchange for a larger but deterministic control latency.
6359 *
6360 * This requires setting the ControlTimesyncFreqHz config in
6361 * MotorOutputConfigs. Additionally, when this is enabled, the
6362 * UpdateFreqHz of this request should be set to 0 Hz.
6363 *
6364 * \param request Control object to request of the device
6365 * \returns Status code of the request
6366 */
6367 ctre::phoenix::StatusCode SetControl(controls::DifferentialDutyCycle const &request) final;
6368
6369 /**
6370 * \brief Request a specified voltage with a differential position
6371 * closed-loop.
6372 *
6373 * \details This control mode will attempt to apply the specified
6374 * voltage to the motor. If the supply voltage is below the requested
6375 * voltage, the motor controller will output the supply voltage. It
6376 * will also set the motor's differential position setpoint to the
6377 * specified position.
6378 *
6379 * - DifferentialVoltage Parameters:
6380 * - AverageOutput: Voltage to attempt to drive at on the Average axis.
6381 * - DifferentialPosition: Differential position to drive towards in
6382 * rotations.
6383 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6384 * which increases peak power by ~15% on supported devices (see
6385 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6386 * commutation.
6387 *
6388 * FOC improves motor performance by leveraging torque (current)
6389 * control. However, this may be inconvenient for applications
6390 * that require specifying duty cycle or voltage.
6391 * CTR-Electronics has developed a hybrid method that combines
6392 * the performances gains of FOC while still allowing
6393 * applications to provide duty cycle or voltage demand. This
6394 * not to be confused with simple sinusoidal control or phase
6395 * voltage control which lacks the performance gains.
6396 * - DifferentialSlot: Select which gains are applied to the differential
6397 * controller by selecting the slot. Use the
6398 * configuration api to set the gain values for the
6399 * selected slot before enabling this feature. Slot must
6400 * be within [0,2].
6401 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6402 * output is zero (or within deadband). Set to
6403 * false to use the NeutralMode configuration
6404 * setting (default). This flag exists to provide
6405 * the fundamental behavior of this control when
6406 * output is zero, which is to provide 0V to the
6407 * motor.
6408 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6409 * users to use other limit switch sensors connected to
6410 * robot controller. This also allows use of active
6411 * sensors that require external power.
6412 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6413 * users to use other limit switch sensors connected to
6414 * robot controller. This also allows use of active
6415 * sensors that require external power.
6416 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6417 * the LimitForwardMotion and LimitReverseMotion
6418 * parameters, instead allowing motion.
6419 *
6420 * This can be useful on mechanisms such as an
6421 * intake/feeder, where a limit switch stops motion
6422 * while intaking but should be ignored when feeding
6423 * to a shooter.
6424 *
6425 * The hardware limit faults and Forward/ReverseLimit
6426 * signals will still report the values of the limit
6427 * switches regardless of this parameter.
6428 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6429 * allowing motion.
6430 *
6431 * This can be useful when calibrating the zero point
6432 * of a mechanism such as an elevator.
6433 *
6434 * The software limit faults will still report the
6435 * values of the software limits regardless of this
6436 * parameter.
6437 * - UseTimesync: Set to true to delay applying this control request until a
6438 * timesync boundary (requires Phoenix Pro and CANivore). This
6439 * eliminates the impact of nondeterministic network delays in
6440 * exchange for a larger but deterministic control latency.
6441 *
6442 * This requires setting the ControlTimesyncFreqHz config in
6443 * MotorOutputConfigs. Additionally, when this is enabled, the
6444 * UpdateFreqHz of this request should be set to 0 Hz.
6445 *
6446 * \param request Control object to request of the device
6447 * \returns Status code of the request
6448 */
6449 ctre::phoenix::StatusCode SetControl(controls::DifferentialVoltage const &request) final;
6450
6451 /**
6452 * \brief Request PID to target position with a differential position
6453 * setpoint.
6454 *
6455 * \details This control mode will set the motor's position setpoint
6456 * to the position specified by the user. It will also set the motor's
6457 * differential position setpoint to the specified position.
6458 *
6459 * - DifferentialPositionDutyCycle Parameters:
6460 * - AveragePosition: Average position to drive toward in rotations.
6461 * - DifferentialPosition: Differential position to drive toward in rotations.
6462 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6463 * which increases peak power by ~15% on supported devices (see
6464 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6465 * commutation.
6466 *
6467 * FOC improves motor performance by leveraging torque (current)
6468 * control. However, this may be inconvenient for applications
6469 * that require specifying duty cycle or voltage.
6470 * CTR-Electronics has developed a hybrid method that combines
6471 * the performances gains of FOC while still allowing
6472 * applications to provide duty cycle or voltage demand. This
6473 * not to be confused with simple sinusoidal control or phase
6474 * voltage control which lacks the performance gains.
6475 * - AverageSlot: Select which gains are applied to the average controller by
6476 * selecting the slot. Use the configuration api to set the
6477 * gain values for the selected slot before enabling this
6478 * feature. Slot must be within [0,2].
6479 * - DifferentialSlot: Select which gains are applied to the differential
6480 * controller by selecting the slot. Use the
6481 * configuration api to set the gain values for the
6482 * selected slot before enabling this feature. Slot must
6483 * be within [0,2].
6484 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6485 * output is zero (or within deadband). Set to
6486 * false to use the NeutralMode configuration
6487 * setting (default). This flag exists to provide
6488 * the fundamental behavior of this control when
6489 * output is zero, which is to provide 0V to the
6490 * motor.
6491 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6492 * users to use other limit switch sensors connected to
6493 * robot controller. This also allows use of active
6494 * sensors that require external power.
6495 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6496 * users to use other limit switch sensors connected to
6497 * robot controller. This also allows use of active
6498 * sensors that require external power.
6499 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6500 * the LimitForwardMotion and LimitReverseMotion
6501 * parameters, instead allowing motion.
6502 *
6503 * This can be useful on mechanisms such as an
6504 * intake/feeder, where a limit switch stops motion
6505 * while intaking but should be ignored when feeding
6506 * to a shooter.
6507 *
6508 * The hardware limit faults and Forward/ReverseLimit
6509 * signals will still report the values of the limit
6510 * switches regardless of this parameter.
6511 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6512 * allowing motion.
6513 *
6514 * This can be useful when calibrating the zero point
6515 * of a mechanism such as an elevator.
6516 *
6517 * The software limit faults will still report the
6518 * values of the software limits regardless of this
6519 * parameter.
6520 * - UseTimesync: Set to true to delay applying this control request until a
6521 * timesync boundary (requires Phoenix Pro and CANivore). This
6522 * eliminates the impact of nondeterministic network delays in
6523 * exchange for a larger but deterministic control latency.
6524 *
6525 * This requires setting the ControlTimesyncFreqHz config in
6526 * MotorOutputConfigs. Additionally, when this is enabled, the
6527 * UpdateFreqHz of this request should be set to 0 Hz.
6528 *
6529 * \param request Control object to request of the device
6530 * \returns Status code of the request
6531 */
6532 ctre::phoenix::StatusCode SetControl(controls::DifferentialPositionDutyCycle const &request) final;
6533
6534 /**
6535 * \brief Request PID to target position with a differential position
6536 * setpoint
6537 *
6538 * \details This control mode will set the motor's position setpoint
6539 * to the position specified by the user. It will also set the motor's
6540 * differential position setpoint to the specified position.
6541 *
6542 * - DifferentialPositionVoltage Parameters:
6543 * - AveragePosition: Average position to drive toward in rotations.
6544 * - DifferentialPosition: Differential position to drive toward in rotations.
6545 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6546 * which increases peak power by ~15% on supported devices (see
6547 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6548 * commutation.
6549 *
6550 * FOC improves motor performance by leveraging torque (current)
6551 * control. However, this may be inconvenient for applications
6552 * that require specifying duty cycle or voltage.
6553 * CTR-Electronics has developed a hybrid method that combines
6554 * the performances gains of FOC while still allowing
6555 * applications to provide duty cycle or voltage demand. This
6556 * not to be confused with simple sinusoidal control or phase
6557 * voltage control which lacks the performance gains.
6558 * - AverageSlot: Select which gains are applied to the average controller by
6559 * selecting the slot. Use the configuration api to set the
6560 * gain values for the selected slot before enabling this
6561 * feature. Slot must be within [0,2].
6562 * - DifferentialSlot: Select which gains are applied to the differential
6563 * controller by selecting the slot. Use the
6564 * configuration api to set the gain values for the
6565 * selected slot before enabling this feature. Slot must
6566 * be within [0,2].
6567 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6568 * output is zero (or within deadband). Set to
6569 * false to use the NeutralMode configuration
6570 * setting (default). This flag exists to provide
6571 * the fundamental behavior of this control when
6572 * output is zero, which is to provide 0V to the
6573 * motor.
6574 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6575 * users to use other limit switch sensors connected to
6576 * robot controller. This also allows use of active
6577 * sensors that require external power.
6578 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6579 * users to use other limit switch sensors connected to
6580 * robot controller. This also allows use of active
6581 * sensors that require external power.
6582 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6583 * the LimitForwardMotion and LimitReverseMotion
6584 * parameters, instead allowing motion.
6585 *
6586 * This can be useful on mechanisms such as an
6587 * intake/feeder, where a limit switch stops motion
6588 * while intaking but should be ignored when feeding
6589 * to a shooter.
6590 *
6591 * The hardware limit faults and Forward/ReverseLimit
6592 * signals will still report the values of the limit
6593 * switches regardless of this parameter.
6594 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6595 * allowing motion.
6596 *
6597 * This can be useful when calibrating the zero point
6598 * of a mechanism such as an elevator.
6599 *
6600 * The software limit faults will still report the
6601 * values of the software limits regardless of this
6602 * parameter.
6603 * - UseTimesync: Set to true to delay applying this control request until a
6604 * timesync boundary (requires Phoenix Pro and CANivore). This
6605 * eliminates the impact of nondeterministic network delays in
6606 * exchange for a larger but deterministic control latency.
6607 *
6608 * This requires setting the ControlTimesyncFreqHz config in
6609 * MotorOutputConfigs. Additionally, when this is enabled, the
6610 * UpdateFreqHz of this request should be set to 0 Hz.
6611 *
6612 * \param request Control object to request of the device
6613 * \returns Status code of the request
6614 */
6615 ctre::phoenix::StatusCode SetControl(controls::DifferentialPositionVoltage const &request) final;
6616
6617 /**
6618 * \brief Request PID to target velocity with a differential position
6619 * setpoint.
6620 *
6621 * \details This control mode will set the motor's velocity setpoint
6622 * to the velocity specified by the user. It will also set the motor's
6623 * differential position setpoint to the specified position.
6624 *
6625 * - DifferentialVelocityDutyCycle Parameters:
6626 * - AverageVelocity: Average velocity to drive toward in rotations per
6627 * second.
6628 * - DifferentialPosition: Differential position to drive toward in rotations.
6629 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6630 * which increases peak power by ~15% on supported devices (see
6631 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6632 * commutation.
6633 *
6634 * FOC improves motor performance by leveraging torque (current)
6635 * control. However, this may be inconvenient for applications
6636 * that require specifying duty cycle or voltage.
6637 * CTR-Electronics has developed a hybrid method that combines
6638 * the performances gains of FOC while still allowing
6639 * applications to provide duty cycle or voltage demand. This
6640 * not to be confused with simple sinusoidal control or phase
6641 * voltage control which lacks the performance gains.
6642 * - AverageSlot: Select which gains are applied to the average controller by
6643 * selecting the slot. Use the configuration api to set the
6644 * gain values for the selected slot before enabling this
6645 * feature. Slot must be within [0,2].
6646 * - DifferentialSlot: Select which gains are applied to the differential
6647 * controller by selecting the slot. Use the
6648 * configuration api to set the gain values for the
6649 * selected slot before enabling this feature. Slot must
6650 * be within [0,2].
6651 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6652 * output is zero (or within deadband). Set to
6653 * false to use the NeutralMode configuration
6654 * setting (default). This flag exists to provide
6655 * the fundamental behavior of this control when
6656 * output is zero, which is to provide 0V to the
6657 * motor.
6658 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6659 * users to use other limit switch sensors connected to
6660 * robot controller. This also allows use of active
6661 * sensors that require external power.
6662 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6663 * users to use other limit switch sensors connected to
6664 * robot controller. This also allows use of active
6665 * sensors that require external power.
6666 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6667 * the LimitForwardMotion and LimitReverseMotion
6668 * parameters, instead allowing motion.
6669 *
6670 * This can be useful on mechanisms such as an
6671 * intake/feeder, where a limit switch stops motion
6672 * while intaking but should be ignored when feeding
6673 * to a shooter.
6674 *
6675 * The hardware limit faults and Forward/ReverseLimit
6676 * signals will still report the values of the limit
6677 * switches regardless of this parameter.
6678 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6679 * allowing motion.
6680 *
6681 * This can be useful when calibrating the zero point
6682 * of a mechanism such as an elevator.
6683 *
6684 * The software limit faults will still report the
6685 * values of the software limits regardless of this
6686 * parameter.
6687 * - UseTimesync: Set to true to delay applying this control request until a
6688 * timesync boundary (requires Phoenix Pro and CANivore). This
6689 * eliminates the impact of nondeterministic network delays in
6690 * exchange for a larger but deterministic control latency.
6691 *
6692 * This requires setting the ControlTimesyncFreqHz config in
6693 * MotorOutputConfigs. Additionally, when this is enabled, the
6694 * UpdateFreqHz of this request should be set to 0 Hz.
6695 *
6696 * \param request Control object to request of the device
6697 * \returns Status code of the request
6698 */
6699 ctre::phoenix::StatusCode SetControl(controls::DifferentialVelocityDutyCycle const &request) final;
6700
6701 /**
6702 * \brief Request PID to target velocity with a differential position
6703 * setpoint.
6704 *
6705 * \details This control mode will set the motor's velocity setpoint
6706 * to the velocity specified by the user. It will also set the motor's
6707 * differential position setpoint to the specified position.
6708 *
6709 * - DifferentialVelocityVoltage Parameters:
6710 * - AverageVelocity: Average velocity to drive toward in rotations per
6711 * second.
6712 * - DifferentialPosition: Differential position to drive toward in rotations.
6713 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6714 * which increases peak power by ~15% on supported devices (see
6715 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6716 * commutation.
6717 *
6718 * FOC improves motor performance by leveraging torque (current)
6719 * control. However, this may be inconvenient for applications
6720 * that require specifying duty cycle or voltage.
6721 * CTR-Electronics has developed a hybrid method that combines
6722 * the performances gains of FOC while still allowing
6723 * applications to provide duty cycle or voltage demand. This
6724 * not to be confused with simple sinusoidal control or phase
6725 * voltage control which lacks the performance gains.
6726 * - AverageSlot: Select which gains are applied to the average controller by
6727 * selecting the slot. Use the configuration api to set the
6728 * gain values for the selected slot before enabling this
6729 * feature. Slot must be within [0,2].
6730 * - DifferentialSlot: Select which gains are applied to the differential
6731 * controller by selecting the slot. Use the
6732 * configuration api to set the gain values for the
6733 * selected slot before enabling this feature. Slot must
6734 * be within [0,2].
6735 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6736 * output is zero (or within deadband). Set to
6737 * false to use the NeutralMode configuration
6738 * setting (default). This flag exists to provide
6739 * the fundamental behavior of this control when
6740 * output is zero, which is to provide 0V to the
6741 * motor.
6742 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6743 * users to use other limit switch sensors connected to
6744 * robot controller. This also allows use of active
6745 * sensors that require external power.
6746 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6747 * users to use other limit switch sensors connected to
6748 * robot controller. This also allows use of active
6749 * sensors that require external power.
6750 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6751 * the LimitForwardMotion and LimitReverseMotion
6752 * parameters, instead allowing motion.
6753 *
6754 * This can be useful on mechanisms such as an
6755 * intake/feeder, where a limit switch stops motion
6756 * while intaking but should be ignored when feeding
6757 * to a shooter.
6758 *
6759 * The hardware limit faults and Forward/ReverseLimit
6760 * signals will still report the values of the limit
6761 * switches regardless of this parameter.
6762 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6763 * allowing motion.
6764 *
6765 * This can be useful when calibrating the zero point
6766 * of a mechanism such as an elevator.
6767 *
6768 * The software limit faults will still report the
6769 * values of the software limits regardless of this
6770 * parameter.
6771 * - UseTimesync: Set to true to delay applying this control request until a
6772 * timesync boundary (requires Phoenix Pro and CANivore). This
6773 * eliminates the impact of nondeterministic network delays in
6774 * exchange for a larger but deterministic control latency.
6775 *
6776 * This requires setting the ControlTimesyncFreqHz config in
6777 * MotorOutputConfigs. Additionally, when this is enabled, the
6778 * UpdateFreqHz of this request should be set to 0 Hz.
6779 *
6780 * \param request Control object to request of the device
6781 * \returns Status code of the request
6782 */
6783 ctre::phoenix::StatusCode SetControl(controls::DifferentialVelocityVoltage const &request) final;
6784
6785 /**
6786 * \brief Requests Motion Magic® to target a final position using a
6787 * motion profile, and PID to a differential position setpoint.
6788 *
6789 * \details Motion Magic® produces a motion profile in real-time while
6790 * attempting to honor the Cruise Velocity, Acceleration, and
6791 * (optional) Jerk specified via the Motion Magic® configuration
6792 * values. This control mode does not use the Expo_kV or Expo_kA
6793 * configs.
6794 *
6795 * Target position can be changed on-the-fly and Motion Magic® will do
6796 * its best to adjust the profile. This control mode is duty cycle
6797 * based, so relevant closed-loop gains will use fractional duty cycle
6798 * for the numerator: +1.0 represents full forward output.
6799 *
6800 * - DifferentialMotionMagicDutyCycle Parameters:
6801 * - AveragePosition: Average position to drive toward in rotations.
6802 * - DifferentialPosition: Differential position to drive toward in rotations.
6803 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6804 * which increases peak power by ~15% on supported devices (see
6805 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6806 * commutation.
6807 *
6808 * FOC improves motor performance by leveraging torque (current)
6809 * control. However, this may be inconvenient for applications
6810 * that require specifying duty cycle or voltage.
6811 * CTR-Electronics has developed a hybrid method that combines
6812 * the performances gains of FOC while still allowing
6813 * applications to provide duty cycle or voltage demand. This
6814 * not to be confused with simple sinusoidal control or phase
6815 * voltage control which lacks the performance gains.
6816 * - AverageSlot: Select which gains are applied to the average controller by
6817 * selecting the slot. Use the configuration api to set the
6818 * gain values for the selected slot before enabling this
6819 * feature. Slot must be within [0,2].
6820 * - DifferentialSlot: Select which gains are applied to the differential
6821 * controller by selecting the slot. Use the
6822 * configuration api to set the gain values for the
6823 * selected slot before enabling this feature. Slot must
6824 * be within [0,2].
6825 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6826 * output is zero (or within deadband). Set to
6827 * false to use the NeutralMode configuration
6828 * setting (default). This flag exists to provide
6829 * the fundamental behavior of this control when
6830 * output is zero, which is to provide 0V to the
6831 * motor.
6832 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6833 * users to use other limit switch sensors connected to
6834 * robot controller. This also allows use of active
6835 * sensors that require external power.
6836 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6837 * users to use other limit switch sensors connected to
6838 * robot controller. This also allows use of active
6839 * sensors that require external power.
6840 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6841 * the LimitForwardMotion and LimitReverseMotion
6842 * parameters, instead allowing motion.
6843 *
6844 * This can be useful on mechanisms such as an
6845 * intake/feeder, where a limit switch stops motion
6846 * while intaking but should be ignored when feeding
6847 * to a shooter.
6848 *
6849 * The hardware limit faults and Forward/ReverseLimit
6850 * signals will still report the values of the limit
6851 * switches regardless of this parameter.
6852 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6853 * allowing motion.
6854 *
6855 * This can be useful when calibrating the zero point
6856 * of a mechanism such as an elevator.
6857 *
6858 * The software limit faults will still report the
6859 * values of the software limits regardless of this
6860 * parameter.
6861 * - UseTimesync: Set to true to delay applying this control request until a
6862 * timesync boundary (requires Phoenix Pro and CANivore). This
6863 * eliminates the impact of nondeterministic network delays in
6864 * exchange for a larger but deterministic control latency.
6865 *
6866 * This requires setting the ControlTimesyncFreqHz config in
6867 * MotorOutputConfigs. Additionally, when this is enabled, the
6868 * UpdateFreqHz of this request should be set to 0 Hz.
6869 *
6870 * \param request Control object to request of the device
6871 * \returns Status code of the request
6872 */
6873 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicDutyCycle const &request) final;
6874
6875 /**
6876 * \brief Requests Motion Magic® to target a final position using a
6877 * motion profile, and PID to a differential position setpoint.
6878 *
6879 * \details Motion Magic® produces a motion profile in real-time while
6880 * attempting to honor the Cruise Velocity, Acceleration, and
6881 * (optional) Jerk specified via the Motion Magic® configuration
6882 * values. This control mode does not use the Expo_kV or Expo_kA
6883 * configs.
6884 *
6885 * Target position can be changed on-the-fly and Motion Magic® will do
6886 * its best to adjust the profile. This control mode is
6887 * voltage-based, so relevant closed-loop gains will use Volts for the
6888 * numerator.
6889 *
6890 * - DifferentialMotionMagicVoltage Parameters:
6891 * - AveragePosition: Average position to drive toward in rotations.
6892 * - DifferentialPosition: Differential position to drive toward in rotations.
6893 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6894 * which increases peak power by ~15% on supported devices (see
6895 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6896 * commutation.
6897 *
6898 * FOC improves motor performance by leveraging torque (current)
6899 * control. However, this may be inconvenient for applications
6900 * that require specifying duty cycle or voltage.
6901 * CTR-Electronics has developed a hybrid method that combines
6902 * the performances gains of FOC while still allowing
6903 * applications to provide duty cycle or voltage demand. This
6904 * not to be confused with simple sinusoidal control or phase
6905 * voltage control which lacks the performance gains.
6906 * - AverageSlot: Select which gains are applied to the average controller by
6907 * selecting the slot. Use the configuration api to set the
6908 * gain values for the selected slot before enabling this
6909 * feature. Slot must be within [0,2].
6910 * - DifferentialSlot: Select which gains are applied to the differential
6911 * controller by selecting the slot. Use the
6912 * configuration api to set the gain values for the
6913 * selected slot before enabling this feature. Slot must
6914 * be within [0,2].
6915 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
6916 * output is zero (or within deadband). Set to
6917 * false to use the NeutralMode configuration
6918 * setting (default). This flag exists to provide
6919 * the fundamental behavior of this control when
6920 * output is zero, which is to provide 0V to the
6921 * motor.
6922 * - LimitForwardMotion: Set to true to force forward limiting. This allows
6923 * users to use other limit switch sensors connected to
6924 * robot controller. This also allows use of active
6925 * sensors that require external power.
6926 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
6927 * users to use other limit switch sensors connected to
6928 * robot controller. This also allows use of active
6929 * sensors that require external power.
6930 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
6931 * the LimitForwardMotion and LimitReverseMotion
6932 * parameters, instead allowing motion.
6933 *
6934 * This can be useful on mechanisms such as an
6935 * intake/feeder, where a limit switch stops motion
6936 * while intaking but should be ignored when feeding
6937 * to a shooter.
6938 *
6939 * The hardware limit faults and Forward/ReverseLimit
6940 * signals will still report the values of the limit
6941 * switches regardless of this parameter.
6942 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
6943 * allowing motion.
6944 *
6945 * This can be useful when calibrating the zero point
6946 * of a mechanism such as an elevator.
6947 *
6948 * The software limit faults will still report the
6949 * values of the software limits regardless of this
6950 * parameter.
6951 * - UseTimesync: Set to true to delay applying this control request until a
6952 * timesync boundary (requires Phoenix Pro and CANivore). This
6953 * eliminates the impact of nondeterministic network delays in
6954 * exchange for a larger but deterministic control latency.
6955 *
6956 * This requires setting the ControlTimesyncFreqHz config in
6957 * MotorOutputConfigs. Additionally, when this is enabled, the
6958 * UpdateFreqHz of this request should be set to 0 Hz.
6959 *
6960 * \param request Control object to request of the device
6961 * \returns Status code of the request
6962 */
6963 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicVoltage const &request) final;
6964
6965 /**
6966 * \brief Requests Motion Magic® to target a final position using an
6967 * exponential motion profile, and PID to a differential position
6968 * setpoint.
6969 *
6970 * \details Motion Magic® Expo produces a motion profile in real-time
6971 * while attempting to honor the Cruise Velocity (optional) and the
6972 * mechanism kV and kA, specified via the Motion Magic® configuration
6973 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
6974 * configs are always in output units of Volts.
6975 *
6976 * Setting Cruise Velocity to 0 will allow the profile to run to the
6977 * max possible velocity based on Expo_kV. This control mode does not
6978 * use the Acceleration or Jerk configs.
6979 *
6980 * Target position can be changed on-the-fly and Motion Magic® will do
6981 * its best to adjust the profile. This control mode is duty cycle
6982 * based, so relevant closed-loop gains will use fractional duty cycle
6983 * for the numerator: +1.0 represents full forward output.
6984 *
6985 * - DifferentialMotionMagicExpoDutyCycle Parameters:
6986 * - AveragePosition: Average position to drive toward in rotations.
6987 * - DifferentialPosition: Differential position to drive toward in rotations.
6988 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
6989 * which increases peak power by ~15% on supported devices (see
6990 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
6991 * commutation.
6992 *
6993 * FOC improves motor performance by leveraging torque (current)
6994 * control. However, this may be inconvenient for applications
6995 * that require specifying duty cycle or voltage.
6996 * CTR-Electronics has developed a hybrid method that combines
6997 * the performances gains of FOC while still allowing
6998 * applications to provide duty cycle or voltage demand. This
6999 * not to be confused with simple sinusoidal control or phase
7000 * voltage control which lacks the performance gains.
7001 * - AverageSlot: Select which gains are applied to the average controller by
7002 * selecting the slot. Use the configuration api to set the
7003 * gain values for the selected slot before enabling this
7004 * feature. Slot must be within [0,2].
7005 * - DifferentialSlot: Select which gains are applied to the differential
7006 * controller by selecting the slot. Use the
7007 * configuration api to set the gain values for the
7008 * selected slot before enabling this feature. Slot must
7009 * be within [0,2].
7010 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7011 * output is zero (or within deadband). Set to
7012 * false to use the NeutralMode configuration
7013 * setting (default). This flag exists to provide
7014 * the fundamental behavior of this control when
7015 * output is zero, which is to provide 0V to the
7016 * motor.
7017 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7018 * users to use other limit switch sensors connected to
7019 * robot controller. This also allows use of active
7020 * sensors that require external power.
7021 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7022 * users to use other limit switch sensors connected to
7023 * robot controller. This also allows use of active
7024 * sensors that require external power.
7025 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7026 * the LimitForwardMotion and LimitReverseMotion
7027 * parameters, instead allowing motion.
7028 *
7029 * This can be useful on mechanisms such as an
7030 * intake/feeder, where a limit switch stops motion
7031 * while intaking but should be ignored when feeding
7032 * to a shooter.
7033 *
7034 * The hardware limit faults and Forward/ReverseLimit
7035 * signals will still report the values of the limit
7036 * switches regardless of this parameter.
7037 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7038 * allowing motion.
7039 *
7040 * This can be useful when calibrating the zero point
7041 * of a mechanism such as an elevator.
7042 *
7043 * The software limit faults will still report the
7044 * values of the software limits regardless of this
7045 * parameter.
7046 * - UseTimesync: Set to true to delay applying this control request until a
7047 * timesync boundary (requires Phoenix Pro and CANivore). This
7048 * eliminates the impact of nondeterministic network delays in
7049 * exchange for a larger but deterministic control latency.
7050 *
7051 * This requires setting the ControlTimesyncFreqHz config in
7052 * MotorOutputConfigs. Additionally, when this is enabled, the
7053 * UpdateFreqHz of this request should be set to 0 Hz.
7054 *
7055 * \param request Control object to request of the device
7056 * \returns Status code of the request
7057 */
7058 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicExpoDutyCycle const &request) final;
7059
7060 /**
7061 * \brief Requests Motion Magic® to target a final position using an
7062 * exponential motion profile, and PID to a differential position
7063 * setpoint.
7064 *
7065 * \details Motion Magic® Expo produces a motion profile in real-time
7066 * while attempting to honor the Cruise Velocity (optional) and the
7067 * mechanism kV and kA, specified via the Motion Magic® configuration
7068 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
7069 * configs are always in output units of Volts.
7070 *
7071 * Setting Cruise Velocity to 0 will allow the profile to run to the
7072 * max possible velocity based on Expo_kV. This control mode does not
7073 * use the Acceleration or Jerk configs.
7074 *
7075 * Target position can be changed on-the-fly and Motion Magic® will do
7076 * its best to adjust the profile. This control mode is
7077 * voltage-based, so relevant closed-loop gains will use Volts for the
7078 * numerator.
7079 *
7080 * - DifferentialMotionMagicExpoVoltage Parameters:
7081 * - AveragePosition: Average position to drive toward in rotations.
7082 * - DifferentialPosition: Differential position to drive toward in rotations.
7083 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7084 * which increases peak power by ~15% on supported devices (see
7085 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7086 * commutation.
7087 *
7088 * FOC improves motor performance by leveraging torque (current)
7089 * control. However, this may be inconvenient for applications
7090 * that require specifying duty cycle or voltage.
7091 * CTR-Electronics has developed a hybrid method that combines
7092 * the performances gains of FOC while still allowing
7093 * applications to provide duty cycle or voltage demand. This
7094 * not to be confused with simple sinusoidal control or phase
7095 * voltage control which lacks the performance gains.
7096 * - AverageSlot: Select which gains are applied to the average controller by
7097 * selecting the slot. Use the configuration api to set the
7098 * gain values for the selected slot before enabling this
7099 * feature. Slot must be within [0,2].
7100 * - DifferentialSlot: Select which gains are applied to the differential
7101 * controller by selecting the slot. Use the
7102 * configuration api to set the gain values for the
7103 * selected slot before enabling this feature. Slot must
7104 * be within [0,2].
7105 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7106 * output is zero (or within deadband). Set to
7107 * false to use the NeutralMode configuration
7108 * setting (default). This flag exists to provide
7109 * the fundamental behavior of this control when
7110 * output is zero, which is to provide 0V to the
7111 * motor.
7112 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7113 * users to use other limit switch sensors connected to
7114 * robot controller. This also allows use of active
7115 * sensors that require external power.
7116 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7117 * users to use other limit switch sensors connected to
7118 * robot controller. This also allows use of active
7119 * sensors that require external power.
7120 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7121 * the LimitForwardMotion and LimitReverseMotion
7122 * parameters, instead allowing motion.
7123 *
7124 * This can be useful on mechanisms such as an
7125 * intake/feeder, where a limit switch stops motion
7126 * while intaking but should be ignored when feeding
7127 * to a shooter.
7128 *
7129 * The hardware limit faults and Forward/ReverseLimit
7130 * signals will still report the values of the limit
7131 * switches regardless of this parameter.
7132 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7133 * allowing motion.
7134 *
7135 * This can be useful when calibrating the zero point
7136 * of a mechanism such as an elevator.
7137 *
7138 * The software limit faults will still report the
7139 * values of the software limits regardless of this
7140 * parameter.
7141 * - UseTimesync: Set to true to delay applying this control request until a
7142 * timesync boundary (requires Phoenix Pro and CANivore). This
7143 * eliminates the impact of nondeterministic network delays in
7144 * exchange for a larger but deterministic control latency.
7145 *
7146 * This requires setting the ControlTimesyncFreqHz config in
7147 * MotorOutputConfigs. Additionally, when this is enabled, the
7148 * UpdateFreqHz of this request should be set to 0 Hz.
7149 *
7150 * \param request Control object to request of the device
7151 * \returns Status code of the request
7152 */
7153 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicExpoVoltage const &request) final;
7154
7155 /**
7156 * \brief Requests Motion Magic® to target a final velocity using a
7157 * motion profile, and PID to a differential position setpoint. This
7158 * allows smooth transitions between velocity set points.
7159 *
7160 * \details Motion Magic® Velocity produces a motion profile in
7161 * real-time while attempting to honor the specified Acceleration and
7162 * (optional) Jerk. This control mode does not use the
7163 * CruiseVelocity, Expo_kV, or Expo_kA configs.
7164 *
7165 * Acceleration and jerk are specified in the Motion Magic® persistent
7166 * configuration values. If Jerk is set to zero, Motion Magic® will
7167 * produce a trapezoidal acceleration profile.
7168 *
7169 * Target velocity can also be changed on-the-fly and Motion Magic®
7170 * will do its best to adjust the profile. This control mode is duty
7171 * cycle based, so relevant closed-loop gains will use fractional duty
7172 * cycle for the numerator: +1.0 represents full forward output.
7173 *
7174 * - DifferentialMotionMagicVelocityDutyCycle Parameters:
7175 * - AverageVelocity: Average velocity to drive toward in rotations per
7176 * second.
7177 * - DifferentialPosition: Differential position to drive toward in rotations.
7178 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7179 * which increases peak power by ~15% on supported devices (see
7180 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7181 * commutation.
7182 *
7183 * FOC improves motor performance by leveraging torque (current)
7184 * control. However, this may be inconvenient for applications
7185 * that require specifying duty cycle or voltage.
7186 * CTR-Electronics has developed a hybrid method that combines
7187 * the performances gains of FOC while still allowing
7188 * applications to provide duty cycle or voltage demand. This
7189 * not to be confused with simple sinusoidal control or phase
7190 * voltage control which lacks the performance gains.
7191 * - AverageSlot: Select which gains are applied to the average controller by
7192 * selecting the slot. Use the configuration api to set the
7193 * gain values for the selected slot before enabling this
7194 * feature. Slot must be within [0,2].
7195 * - DifferentialSlot: Select which gains are applied to the differential
7196 * controller by selecting the slot. Use the
7197 * configuration api to set the gain values for the
7198 * selected slot before enabling this feature. Slot must
7199 * be within [0,2].
7200 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7201 * output is zero (or within deadband). Set to
7202 * false to use the NeutralMode configuration
7203 * setting (default). This flag exists to provide
7204 * the fundamental behavior of this control when
7205 * output is zero, which is to provide 0V to the
7206 * motor.
7207 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7208 * users to use other limit switch sensors connected to
7209 * robot controller. This also allows use of active
7210 * sensors that require external power.
7211 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7212 * users to use other limit switch sensors connected to
7213 * robot controller. This also allows use of active
7214 * sensors that require external power.
7215 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7216 * the LimitForwardMotion and LimitReverseMotion
7217 * parameters, instead allowing motion.
7218 *
7219 * This can be useful on mechanisms such as an
7220 * intake/feeder, where a limit switch stops motion
7221 * while intaking but should be ignored when feeding
7222 * to a shooter.
7223 *
7224 * The hardware limit faults and Forward/ReverseLimit
7225 * signals will still report the values of the limit
7226 * switches regardless of this parameter.
7227 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7228 * allowing motion.
7229 *
7230 * This can be useful when calibrating the zero point
7231 * of a mechanism such as an elevator.
7232 *
7233 * The software limit faults will still report the
7234 * values of the software limits regardless of this
7235 * parameter.
7236 * - UseTimesync: Set to true to delay applying this control request until a
7237 * timesync boundary (requires Phoenix Pro and CANivore). This
7238 * eliminates the impact of nondeterministic network delays in
7239 * exchange for a larger but deterministic control latency.
7240 *
7241 * This requires setting the ControlTimesyncFreqHz config in
7242 * MotorOutputConfigs. Additionally, when this is enabled, the
7243 * UpdateFreqHz of this request should be set to 0 Hz.
7244 *
7245 * \param request Control object to request of the device
7246 * \returns Status code of the request
7247 */
7248 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicVelocityDutyCycle const &request) final;
7249
7250 /**
7251 * \brief Requests Motion Magic® to target a final velocity using a
7252 * motion profile, and PID to a differential position setpoint. This
7253 * allows smooth transitions between velocity set points.
7254 *
7255 * \details Motion Magic® Velocity produces a motion profile in
7256 * real-time while attempting to honor the specified Acceleration and
7257 * (optional) Jerk. This control mode does not use the
7258 * CruiseVelocity, Expo_kV, or Expo_kA configs.
7259 *
7260 * Acceleration and jerk are specified in the Motion Magic® persistent
7261 * configuration values. If Jerk is set to zero, Motion Magic® will
7262 * produce a trapezoidal acceleration profile.
7263 *
7264 * Target velocity can also be changed on-the-fly and Motion Magic®
7265 * will do its best to adjust the profile. This control mode is
7266 * voltage-based, so relevant closed-loop gains will use Volts for the
7267 * numerator.
7268 *
7269 * - DifferentialMotionMagicVelocityVoltage Parameters:
7270 * - AverageVelocity: Average velocity to drive toward in rotations per
7271 * second.
7272 * - DifferentialPosition: Differential position to drive toward in rotations.
7273 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7274 * which increases peak power by ~15% on supported devices (see
7275 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7276 * commutation.
7277 *
7278 * FOC improves motor performance by leveraging torque (current)
7279 * control. However, this may be inconvenient for applications
7280 * that require specifying duty cycle or voltage.
7281 * CTR-Electronics has developed a hybrid method that combines
7282 * the performances gains of FOC while still allowing
7283 * applications to provide duty cycle or voltage demand. This
7284 * not to be confused with simple sinusoidal control or phase
7285 * voltage control which lacks the performance gains.
7286 * - AverageSlot: Select which gains are applied to the average controller by
7287 * selecting the slot. Use the configuration api to set the
7288 * gain values for the selected slot before enabling this
7289 * feature. Slot must be within [0,2].
7290 * - DifferentialSlot: Select which gains are applied to the differential
7291 * controller by selecting the slot. Use the
7292 * configuration api to set the gain values for the
7293 * selected slot before enabling this feature. Slot must
7294 * be within [0,2].
7295 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7296 * output is zero (or within deadband). Set to
7297 * false to use the NeutralMode configuration
7298 * setting (default). This flag exists to provide
7299 * the fundamental behavior of this control when
7300 * output is zero, which is to provide 0V to the
7301 * motor.
7302 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7303 * users to use other limit switch sensors connected to
7304 * robot controller. This also allows use of active
7305 * sensors that require external power.
7306 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7307 * users to use other limit switch sensors connected to
7308 * robot controller. This also allows use of active
7309 * sensors that require external power.
7310 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7311 * the LimitForwardMotion and LimitReverseMotion
7312 * parameters, instead allowing motion.
7313 *
7314 * This can be useful on mechanisms such as an
7315 * intake/feeder, where a limit switch stops motion
7316 * while intaking but should be ignored when feeding
7317 * to a shooter.
7318 *
7319 * The hardware limit faults and Forward/ReverseLimit
7320 * signals will still report the values of the limit
7321 * switches regardless of this parameter.
7322 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7323 * allowing motion.
7324 *
7325 * This can be useful when calibrating the zero point
7326 * of a mechanism such as an elevator.
7327 *
7328 * The software limit faults will still report the
7329 * values of the software limits regardless of this
7330 * parameter.
7331 * - UseTimesync: Set to true to delay applying this control request until a
7332 * timesync boundary (requires Phoenix Pro and CANivore). This
7333 * eliminates the impact of nondeterministic network delays in
7334 * exchange for a larger but deterministic control latency.
7335 *
7336 * This requires setting the ControlTimesyncFreqHz config in
7337 * MotorOutputConfigs. Additionally, when this is enabled, the
7338 * UpdateFreqHz of this request should be set to 0 Hz.
7339 *
7340 * \param request Control object to request of the device
7341 * \returns Status code of the request
7342 */
7343 ctre::phoenix::StatusCode SetControl(controls::DifferentialMotionMagicVelocityVoltage const &request) final;
7344
7345 /**
7346 * \brief Follow the motor output of another Talon.
7347 *
7348 * \details The follower will atomically change its output type when
7349 * it receives the leader's latest output status signal (DutyCycle,
7350 * MotorVoltage, TorqueCurrent). If Talon is in torque control, the
7351 * torque is copied - which will increase the total torque applied. If
7352 * Talon is in duty cycle output control, the duty cycle is matched.
7353 * If Talon is in voltage output control, the motor voltage is
7354 * matched. Motor direction either matches the leader's configured
7355 * direction or opposes it based on the MotorAlignment.
7356 *
7357 * The leader must ensure the status signal corresponding to its
7358 * control output type (DutyCycle, MotorVoltage, TorqueCurrent) is
7359 * enabled. The update rate of the status signal determines the update
7360 * rate of the follower's output and should be no slower than 20 Hz.
7361 *
7362 * - Follower Parameters:
7363 * - LeaderID: Device ID of the leader to follow.
7364 * - MotorAlignment: Set to Aligned for motor invert to match the leader's
7365 * configured Invert - which is typical when leader and
7366 * follower are mechanically linked and spin in the same
7367 * direction. Set to Opposed for motor invert to oppose the
7368 * leader's configured Invert - this is typical where the
7369 * leader and follower mechanically spin in opposite
7370 * directions.
7371 *
7372 * \param request Control object to request of the device
7373 * \returns Status code of the request
7374 */
7375 ctre::phoenix::StatusCode SetControl(controls::Follower const &request) final;
7376
7377 /**
7378 * \brief Follow the motor output of another Talon while ignoring the
7379 * leader's invert setting.
7380 *
7381 * \details The follower will atomically change its output type when
7382 * it receives the leader's latest output status signal (DutyCycle,
7383 * MotorVoltage, TorqueCurrent). If Talon is in torque control, the
7384 * torque is copied - which will increase the total torque applied. If
7385 * Talon is in duty cycle output control, the duty cycle is matched.
7386 * If Talon is in voltage output control, the motor voltage is
7387 * matched. Motor direction is strictly determined by the configured
7388 * invert and not the leader. If you want motor direction to match or
7389 * oppose the leader, use Follower instead.
7390 *
7391 * The leader must ensure the status signal corresponding to its
7392 * control output type (DutyCycle, MotorVoltage, TorqueCurrent) is
7393 * enabled. The update rate of the status signal determines the update
7394 * rate of the follower's output and should be no slower than 20 Hz.
7395 *
7396 * - StrictFollower Parameters:
7397 * - LeaderID: Device ID of the leader to follow.
7398 *
7399 * \param request Control object to request of the device
7400 * \returns Status code of the request
7401 */
7402 ctre::phoenix::StatusCode SetControl(controls::StrictFollower const &request) final;
7403
7404 /**
7405 * \brief Follow the differential motor output of another Talon.
7406 *
7407 * \details If Talon is in torque control, the differential torque is
7408 * copied - which will increase the total torque applied. If Talon is
7409 * in duty cycle output control, the differential duty cycle is
7410 * matched. If Talon is in voltage output control, the differential
7411 * motor voltage is matched. Motor direction either matches leader's
7412 * configured direction or opposes it based on the MotorAlignment.
7413 *
7414 * The leader must enable its DifferentialOutput status signal. The
7415 * update rate of the status signal determines the update rate of the
7416 * follower's output and should be no slower than 20 Hz.
7417 *
7418 * - DifferentialFollower Parameters:
7419 * - LeaderID: Device ID of the differential leader to follow.
7420 * - MotorAlignment: Set to Aligned for motor invert to match the leader's
7421 * configured Invert - which is typical when leader and
7422 * follower are mechanically linked and spin in the same
7423 * direction. Set to Opposed for motor invert to oppose the
7424 * leader's configured Invert - this is typical where the
7425 * leader and follower mechanically spin in opposite
7426 * directions.
7427 *
7428 * \param request Control object to request of the device
7429 * \returns Status code of the request
7430 */
7431 ctre::phoenix::StatusCode SetControl(controls::DifferentialFollower const &request) final;
7432
7433 /**
7434 * \brief Follow the differential motor output of another Talon while
7435 * ignoring the leader's invert setting.
7436 *
7437 * \details If Talon is in torque control, the differential torque is
7438 * copied - which will increase the total torque applied. If Talon is
7439 * in duty cycle output control, the differential duty cycle is
7440 * matched. If Talon is in voltage output control, the differential
7441 * motor voltage is matched. Motor direction is strictly determined by
7442 * the configured invert and not the leader. If you want motor
7443 * direction to match or oppose the leader, use DifferentialFollower
7444 * instead.
7445 *
7446 * The leader must enable its DifferentialOutput status signal. The
7447 * update rate of the status signal determines the update rate of the
7448 * follower's output and should be no slower than 20 Hz.
7449 *
7450 * - DifferentialStrictFollower Parameters:
7451 * - LeaderID: Device ID of the differential leader to follow.
7452 *
7453 * \param request Control object to request of the device
7454 * \returns Status code of the request
7455 */
7456 ctre::phoenix::StatusCode SetControl(controls::DifferentialStrictFollower const &request) final;
7457
7458 /**
7459 * \brief Request neutral output of actuator. The applied brake type
7460 * is determined by the NeutralMode configuration.
7461 *
7462 * - NeutralOut Parameters:
7463 * - UseTimesync: Set to true to delay applying this control request until a
7464 * timesync boundary (requires Phoenix Pro and CANivore). This
7465 * eliminates the impact of nondeterministic network delays in
7466 * exchange for a larger but deterministic control latency.
7467 *
7468 * This requires setting the ControlTimesyncFreqHz config in
7469 * MotorOutputConfigs. Additionally, when this is enabled, the
7470 * UpdateFreqHz of this request should be set to 0 Hz.
7471 *
7472 * \param request Control object to request of the device
7473 * \returns Status code of the request
7474 */
7475 ctre::phoenix::StatusCode SetControl(controls::NeutralOut const &request) final;
7476
7477 /**
7478 * \brief Request coast neutral output of actuator. The bridge is
7479 * disabled and the rotor is allowed to coast.
7480 *
7481 * - CoastOut Parameters:
7482 * - UseTimesync: Set to true to delay applying this control request until a
7483 * timesync boundary (requires Phoenix Pro and CANivore). This
7484 * eliminates the impact of nondeterministic network delays in
7485 * exchange for a larger but deterministic control latency.
7486 *
7487 * This requires setting the ControlTimesyncFreqHz config in
7488 * MotorOutputConfigs. Additionally, when this is enabled, the
7489 * UpdateFreqHz of this request should be set to 0 Hz.
7490 *
7491 * \param request Control object to request of the device
7492 * \returns Status code of the request
7493 */
7494 ctre::phoenix::StatusCode SetControl(controls::CoastOut const &request) final;
7495
7496 /**
7497 * \brief Applies full neutral-brake by shorting motor leads together.
7498 *
7499 * - StaticBrake Parameters:
7500 * - UseTimesync: Set to true to delay applying this control request until a
7501 * timesync boundary (requires Phoenix Pro and CANivore). This
7502 * eliminates the impact of nondeterministic network delays in
7503 * exchange for a larger but deterministic control latency.
7504 *
7505 * This requires setting the ControlTimesyncFreqHz config in
7506 * MotorOutputConfigs. Additionally, when this is enabled, the
7507 * UpdateFreqHz of this request should be set to 0 Hz.
7508 *
7509 * \param request Control object to request of the device
7510 * \returns Status code of the request
7511 */
7512 ctre::phoenix::StatusCode SetControl(controls::StaticBrake const &request) final;
7513
7514 /**
7515 * \brief Plays a single tone at the user specified frequency.
7516 *
7517 * - MusicTone Parameters:
7518 * - AudioFrequency: Sound frequency to play. A value of zero will silence
7519 * the device. The effective frequency range is 10-20000 Hz.
7520 * Any nonzero frequency less than 10 Hz will be capped to
7521 * 10 Hz. Any frequency above 20 kHz will be capped to 20
7522 * kHz.
7523 *
7524 * \param request Control object to request of the device
7525 * \returns Status code of the request
7526 */
7527 ctre::phoenix::StatusCode SetControl(controls::MusicTone const &request) final;
7528
7529 /**
7530 * \brief Requests Motion Magic® to target a final velocity using a
7531 * motion profile. This allows smooth transitions between velocity
7532 * set points. Users can optionally provide a duty cycle feedforward.
7533 *
7534 * \details Motion Magic® Velocity produces a motion profile in
7535 * real-time while attempting to honor the specified Acceleration and
7536 * (optional) Jerk. This control mode does not use the
7537 * CruiseVelocity, Expo_kV, or Expo_kA configs.
7538 *
7539 * If the specified acceleration is zero, the Acceleration under
7540 * Motion Magic® configuration parameter is used instead. This allows
7541 * for runtime adjustment of acceleration for advanced users. Jerk is
7542 * also specified in the Motion Magic® persistent configuration
7543 * values. If Jerk is set to zero, Motion Magic® will produce a
7544 * trapezoidal acceleration profile.
7545 *
7546 * Target velocity can also be changed on-the-fly and Motion Magic®
7547 * will do its best to adjust the profile. This control mode is duty
7548 * cycle based, so relevant closed-loop gains will use fractional duty
7549 * cycle for the numerator: +1.0 represents full forward output.
7550 *
7551 * - MotionMagicVelocityDutyCycle Parameters:
7552 * - Velocity: Target velocity to drive toward in rotations per second. This
7553 * can be changed on-the fly.
7554 * - Acceleration: This is the absolute Acceleration to use generating the
7555 * profile. If this parameter is zero, the Acceleration
7556 * persistent configuration parameter is used instead.
7557 * Acceleration is in rotations per second squared. If
7558 * nonzero, the signage does not matter as the absolute value
7559 * is used.
7560 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7561 * which increases peak power by ~15% on supported devices (see
7562 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7563 * commutation.
7564 *
7565 * FOC improves motor performance by leveraging torque (current)
7566 * control. However, this may be inconvenient for applications
7567 * that require specifying duty cycle or voltage.
7568 * CTR-Electronics has developed a hybrid method that combines
7569 * the performances gains of FOC while still allowing
7570 * applications to provide duty cycle or voltage demand. This
7571 * not to be confused with simple sinusoidal control or phase
7572 * voltage control which lacks the performance gains.
7573 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
7574 * This is added to the output of the onboard feedforward
7575 * terms.
7576 * - Slot: Select which gains are applied by selecting the slot. Use the
7577 * configuration api to set the gain values for the selected slot
7578 * before enabling this feature. Slot must be within [0,2].
7579 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7580 * output is zero (or within deadband). Set to
7581 * false to use the NeutralMode configuration
7582 * setting (default). This flag exists to provide
7583 * the fundamental behavior of this control when
7584 * output is zero, which is to provide 0V to the
7585 * motor.
7586 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7587 * users to use other limit switch sensors connected to
7588 * robot controller. This also allows use of active
7589 * sensors that require external power.
7590 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7591 * users to use other limit switch sensors connected to
7592 * robot controller. This also allows use of active
7593 * sensors that require external power.
7594 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7595 * the LimitForwardMotion and LimitReverseMotion
7596 * parameters, instead allowing motion.
7597 *
7598 * This can be useful on mechanisms such as an
7599 * intake/feeder, where a limit switch stops motion
7600 * while intaking but should be ignored when feeding
7601 * to a shooter.
7602 *
7603 * The hardware limit faults and Forward/ReverseLimit
7604 * signals will still report the values of the limit
7605 * switches regardless of this parameter.
7606 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7607 * allowing motion.
7608 *
7609 * This can be useful when calibrating the zero point
7610 * of a mechanism such as an elevator.
7611 *
7612 * The software limit faults will still report the
7613 * values of the software limits regardless of this
7614 * parameter.
7615 * - UseTimesync: Set to true to delay applying this control request until a
7616 * timesync boundary (requires Phoenix Pro and CANivore). This
7617 * eliminates the impact of nondeterministic network delays in
7618 * exchange for a larger but deterministic control latency.
7619 *
7620 * This requires setting the ControlTimesyncFreqHz config in
7621 * MotorOutputConfigs. Additionally, when this is enabled, the
7622 * UpdateFreqHz of this request should be set to 0 Hz.
7623 *
7624 * \param request Control object to request of the device
7625 * \returns Status code of the request
7626 */
7627 ctre::phoenix::StatusCode SetControl(controls::MotionMagicVelocityDutyCycle const &request) final;
7628
7629 /**
7630 * \brief Requests Motion Magic® to target a final velocity using a
7631 * motion profile. This allows smooth transitions between velocity
7632 * set points. Users can optionally provide a torque feedforward.
7633 *
7634 * \details Motion Magic® Velocity produces a motion profile in
7635 * real-time while attempting to honor the specified Acceleration and
7636 * (optional) Jerk. This control mode does not use the
7637 * CruiseVelocity, Expo_kV, or Expo_kA configs.
7638 *
7639 * If the specified acceleration is zero, the Acceleration under
7640 * Motion Magic® configuration parameter is used instead. This allows
7641 * for runtime adjustment of acceleration for advanced users. Jerk is
7642 * also specified in the Motion Magic® persistent configuration
7643 * values. If Jerk is set to zero, Motion Magic® will produce a
7644 * trapezoidal acceleration profile.
7645 *
7646 * Target velocity can also be changed on-the-fly and Motion Magic®
7647 * will do its best to adjust the profile. This control mode is based
7648 * on torque current, so relevant closed-loop gains will use Amperes
7649 * for the numerator.
7650 *
7651 * - MotionMagicVelocityTorqueCurrentFOC Parameters:
7652 * - Velocity: Target velocity to drive toward in rotations per second. This
7653 * can be changed on-the fly.
7654 * - Acceleration: This is the absolute Acceleration to use generating the
7655 * profile. If this parameter is zero, the Acceleration
7656 * persistent configuration parameter is used instead.
7657 * Acceleration is in rotations per second squared. If
7658 * nonzero, the signage does not matter as the absolute value
7659 * is used.
7660 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
7661 * added to the output of the onboard feedforward terms.
7662 *
7663 * User can use motor's kT to scale Newton-meter to Amperes.
7664 * - Slot: Select which gains are applied by selecting the slot. Use the
7665 * configuration api to set the gain values for the selected slot
7666 * before enabling this feature. Slot must be within [0,2].
7667 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
7668 * zero (or within deadband). Set to false to use
7669 * the NeutralMode configuration setting (default).
7670 * This flag exists to provide the fundamental
7671 * behavior of this control when output is zero,
7672 * which is to provide 0A (zero torque).
7673 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7674 * users to use other limit switch sensors connected to
7675 * robot controller. This also allows use of active
7676 * sensors that require external power.
7677 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7678 * users to use other limit switch sensors connected to
7679 * robot controller. This also allows use of active
7680 * sensors that require external power.
7681 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7682 * the LimitForwardMotion and LimitReverseMotion
7683 * parameters, instead allowing motion.
7684 *
7685 * This can be useful on mechanisms such as an
7686 * intake/feeder, where a limit switch stops motion
7687 * while intaking but should be ignored when feeding
7688 * to a shooter.
7689 *
7690 * The hardware limit faults and Forward/ReverseLimit
7691 * signals will still report the values of the limit
7692 * switches regardless of this parameter.
7693 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7694 * allowing motion.
7695 *
7696 * This can be useful when calibrating the zero point
7697 * of a mechanism such as an elevator.
7698 *
7699 * The software limit faults will still report the
7700 * values of the software limits regardless of this
7701 * parameter.
7702 * - UseTimesync: Set to true to delay applying this control request until a
7703 * timesync boundary (requires Phoenix Pro and CANivore). This
7704 * eliminates the impact of nondeterministic network delays in
7705 * exchange for a larger but deterministic control latency.
7706 *
7707 * This requires setting the ControlTimesyncFreqHz config in
7708 * MotorOutputConfigs. Additionally, when this is enabled, the
7709 * UpdateFreqHz of this request should be set to 0 Hz.
7710 *
7711 * \param request Control object to request of the device
7712 * \returns Status code of the request
7713 */
7714 ctre::phoenix::StatusCode SetControl(controls::MotionMagicVelocityTorqueCurrentFOC const &request) final;
7715
7716 /**
7717 * \brief Requests Motion Magic® to target a final velocity using a
7718 * motion profile. This allows smooth transitions between velocity
7719 * set points. Users can optionally provide a voltage feedforward.
7720 *
7721 * \details Motion Magic® Velocity produces a motion profile in
7722 * real-time while attempting to honor the specified Acceleration and
7723 * (optional) Jerk. This control mode does not use the
7724 * CruiseVelocity, Expo_kV, or Expo_kA configs.
7725 *
7726 * If the specified acceleration is zero, the Acceleration under
7727 * Motion Magic® configuration parameter is used instead. This allows
7728 * for runtime adjustment of acceleration for advanced users. Jerk is
7729 * also specified in the Motion Magic® persistent configuration
7730 * values. If Jerk is set to zero, Motion Magic® will produce a
7731 * trapezoidal acceleration profile.
7732 *
7733 * Target velocity can also be changed on-the-fly and Motion Magic®
7734 * will do its best to adjust the profile. This control mode is
7735 * voltage-based, so relevant closed-loop gains will use Volts for the
7736 * numerator.
7737 *
7738 * - MotionMagicVelocityVoltage Parameters:
7739 * - Velocity: Target velocity to drive toward in rotations per second. This
7740 * can be changed on-the fly.
7741 * - Acceleration: This is the absolute Acceleration to use generating the
7742 * profile. If this parameter is zero, the Acceleration
7743 * persistent configuration parameter is used instead.
7744 * Acceleration is in rotations per second squared. If
7745 * nonzero, the signage does not matter as the absolute value
7746 * is used.
7747 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7748 * which increases peak power by ~15% on supported devices (see
7749 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7750 * commutation.
7751 *
7752 * FOC improves motor performance by leveraging torque (current)
7753 * control. However, this may be inconvenient for applications
7754 * that require specifying duty cycle or voltage.
7755 * CTR-Electronics has developed a hybrid method that combines
7756 * the performances gains of FOC while still allowing
7757 * applications to provide duty cycle or voltage demand. This
7758 * not to be confused with simple sinusoidal control or phase
7759 * voltage control which lacks the performance gains.
7760 * - FeedForward: Feedforward to apply in volts. This is added to the output
7761 * of the onboard feedforward terms.
7762 * - Slot: Select which gains are applied by selecting the slot. Use the
7763 * configuration api to set the gain values for the selected slot
7764 * before enabling this feature. Slot must be within [0,2].
7765 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7766 * output is zero (or within deadband). Set to
7767 * false to use the NeutralMode configuration
7768 * setting (default). This flag exists to provide
7769 * the fundamental behavior of this control when
7770 * output is zero, which is to provide 0V to the
7771 * motor.
7772 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7773 * users to use other limit switch sensors connected to
7774 * robot controller. This also allows use of active
7775 * sensors that require external power.
7776 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7777 * users to use other limit switch sensors connected to
7778 * robot controller. This also allows use of active
7779 * sensors that require external power.
7780 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7781 * the LimitForwardMotion and LimitReverseMotion
7782 * parameters, instead allowing motion.
7783 *
7784 * This can be useful on mechanisms such as an
7785 * intake/feeder, where a limit switch stops motion
7786 * while intaking but should be ignored when feeding
7787 * to a shooter.
7788 *
7789 * The hardware limit faults and Forward/ReverseLimit
7790 * signals will still report the values of the limit
7791 * switches regardless of this parameter.
7792 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7793 * allowing motion.
7794 *
7795 * This can be useful when calibrating the zero point
7796 * of a mechanism such as an elevator.
7797 *
7798 * The software limit faults will still report the
7799 * values of the software limits regardless of this
7800 * parameter.
7801 * - UseTimesync: Set to true to delay applying this control request until a
7802 * timesync boundary (requires Phoenix Pro and CANivore). This
7803 * eliminates the impact of nondeterministic network delays in
7804 * exchange for a larger but deterministic control latency.
7805 *
7806 * This requires setting the ControlTimesyncFreqHz config in
7807 * MotorOutputConfigs. Additionally, when this is enabled, the
7808 * UpdateFreqHz of this request should be set to 0 Hz.
7809 *
7810 * \param request Control object to request of the device
7811 * \returns Status code of the request
7812 */
7813 ctre::phoenix::StatusCode SetControl(controls::MotionMagicVelocityVoltage const &request) final;
7814
7815 /**
7816 * \brief Requests Motion Magic® to target a final position using an
7817 * exponential motion profile. Users can optionally provide a duty
7818 * cycle feedforward.
7819 *
7820 * \details Motion Magic® Expo produces a motion profile in real-time
7821 * while attempting to honor the Cruise Velocity (optional) and the
7822 * mechanism kV and kA, specified via the Motion Magic® configuration
7823 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
7824 * configs are always in output units of Volts.
7825 *
7826 * Setting Cruise Velocity to 0 will allow the profile to run to the
7827 * max possible velocity based on Expo_kV. This control mode does not
7828 * use the Acceleration or Jerk configs.
7829 *
7830 * Target position can be changed on-the-fly and Motion Magic® will do
7831 * its best to adjust the profile. This control mode is duty cycle
7832 * based, so relevant closed-loop gains will use fractional duty cycle
7833 * for the numerator: +1.0 represents full forward output.
7834 *
7835 * - MotionMagicExpoDutyCycle Parameters:
7836 * - Position: Position to drive toward in rotations.
7837 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7838 * which increases peak power by ~15% on supported devices (see
7839 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7840 * commutation.
7841 *
7842 * FOC improves motor performance by leveraging torque (current)
7843 * control. However, this may be inconvenient for applications
7844 * that require specifying duty cycle or voltage.
7845 * CTR-Electronics has developed a hybrid method that combines
7846 * the performances gains of FOC while still allowing
7847 * applications to provide duty cycle or voltage demand. This
7848 * not to be confused with simple sinusoidal control or phase
7849 * voltage control which lacks the performance gains.
7850 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
7851 * This is added to the output of the onboard feedforward
7852 * terms.
7853 * - Slot: Select which gains are applied by selecting the slot. Use the
7854 * configuration api to set the gain values for the selected slot
7855 * before enabling this feature. Slot must be within [0,2].
7856 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7857 * output is zero (or within deadband). Set to
7858 * false to use the NeutralMode configuration
7859 * setting (default). This flag exists to provide
7860 * the fundamental behavior of this control when
7861 * output is zero, which is to provide 0V to the
7862 * motor.
7863 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7864 * users to use other limit switch sensors connected to
7865 * robot controller. This also allows use of active
7866 * sensors that require external power.
7867 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7868 * users to use other limit switch sensors connected to
7869 * robot controller. This also allows use of active
7870 * sensors that require external power.
7871 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7872 * the LimitForwardMotion and LimitReverseMotion
7873 * parameters, instead allowing motion.
7874 *
7875 * This can be useful on mechanisms such as an
7876 * intake/feeder, where a limit switch stops motion
7877 * while intaking but should be ignored when feeding
7878 * to a shooter.
7879 *
7880 * The hardware limit faults and Forward/ReverseLimit
7881 * signals will still report the values of the limit
7882 * switches regardless of this parameter.
7883 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7884 * allowing motion.
7885 *
7886 * This can be useful when calibrating the zero point
7887 * of a mechanism such as an elevator.
7888 *
7889 * The software limit faults will still report the
7890 * values of the software limits regardless of this
7891 * parameter.
7892 * - UseTimesync: Set to true to delay applying this control request until a
7893 * timesync boundary (requires Phoenix Pro and CANivore). This
7894 * eliminates the impact of nondeterministic network delays in
7895 * exchange for a larger but deterministic control latency.
7896 *
7897 * This requires setting the ControlTimesyncFreqHz config in
7898 * MotorOutputConfigs. Additionally, when this is enabled, the
7899 * UpdateFreqHz of this request should be set to 0 Hz.
7900 *
7901 * \param request Control object to request of the device
7902 * \returns Status code of the request
7903 */
7904 ctre::phoenix::StatusCode SetControl(controls::MotionMagicExpoDutyCycle const &request) final;
7905
7906 /**
7907 * \brief Requests Motion Magic® to target a final position using an
7908 * exponential motion profile. Users can optionally provide a voltage
7909 * feedforward.
7910 *
7911 * \details Motion Magic® Expo produces a motion profile in real-time
7912 * while attempting to honor the Cruise Velocity (optional) and the
7913 * mechanism kV and kA, specified via the Motion Magic® configuration
7914 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
7915 * configs are always in output units of Volts.
7916 *
7917 * Setting Cruise Velocity to 0 will allow the profile to run to the
7918 * max possible velocity based on Expo_kV. This control mode does not
7919 * use the Acceleration or Jerk configs.
7920 *
7921 * Target position can be changed on-the-fly and Motion Magic® will do
7922 * its best to adjust the profile. This control mode is
7923 * voltage-based, so relevant closed-loop gains will use Volts for the
7924 * numerator.
7925 *
7926 * - MotionMagicExpoVoltage Parameters:
7927 * - Position: Position to drive toward in rotations.
7928 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
7929 * which increases peak power by ~15% on supported devices (see
7930 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
7931 * commutation.
7932 *
7933 * FOC improves motor performance by leveraging torque (current)
7934 * control. However, this may be inconvenient for applications
7935 * that require specifying duty cycle or voltage.
7936 * CTR-Electronics has developed a hybrid method that combines
7937 * the performances gains of FOC while still allowing
7938 * applications to provide duty cycle or voltage demand. This
7939 * not to be confused with simple sinusoidal control or phase
7940 * voltage control which lacks the performance gains.
7941 * - FeedForward: Feedforward to apply in volts. This is added to the output
7942 * of the onboard feedforward terms.
7943 * - Slot: Select which gains are applied by selecting the slot. Use the
7944 * configuration api to set the gain values for the selected slot
7945 * before enabling this feature. Slot must be within [0,2].
7946 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
7947 * output is zero (or within deadband). Set to
7948 * false to use the NeutralMode configuration
7949 * setting (default). This flag exists to provide
7950 * the fundamental behavior of this control when
7951 * output is zero, which is to provide 0V to the
7952 * motor.
7953 * - LimitForwardMotion: Set to true to force forward limiting. This allows
7954 * users to use other limit switch sensors connected to
7955 * robot controller. This also allows use of active
7956 * sensors that require external power.
7957 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
7958 * users to use other limit switch sensors connected to
7959 * robot controller. This also allows use of active
7960 * sensors that require external power.
7961 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
7962 * the LimitForwardMotion and LimitReverseMotion
7963 * parameters, instead allowing motion.
7964 *
7965 * This can be useful on mechanisms such as an
7966 * intake/feeder, where a limit switch stops motion
7967 * while intaking but should be ignored when feeding
7968 * to a shooter.
7969 *
7970 * The hardware limit faults and Forward/ReverseLimit
7971 * signals will still report the values of the limit
7972 * switches regardless of this parameter.
7973 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
7974 * allowing motion.
7975 *
7976 * This can be useful when calibrating the zero point
7977 * of a mechanism such as an elevator.
7978 *
7979 * The software limit faults will still report the
7980 * values of the software limits regardless of this
7981 * parameter.
7982 * - UseTimesync: Set to true to delay applying this control request until a
7983 * timesync boundary (requires Phoenix Pro and CANivore). This
7984 * eliminates the impact of nondeterministic network delays in
7985 * exchange for a larger but deterministic control latency.
7986 *
7987 * This requires setting the ControlTimesyncFreqHz config in
7988 * MotorOutputConfigs. Additionally, when this is enabled, the
7989 * UpdateFreqHz of this request should be set to 0 Hz.
7990 *
7991 * \param request Control object to request of the device
7992 * \returns Status code of the request
7993 */
7994 ctre::phoenix::StatusCode SetControl(controls::MotionMagicExpoVoltage const &request) final;
7995
7996 /**
7997 * \brief Requests Motion Magic® to target a final position using an
7998 * exponential motion profile. Users can optionally provide a torque
7999 * current feedforward.
8000 *
8001 * \details Motion Magic® Expo produces a motion profile in real-time
8002 * while attempting to honor the Cruise Velocity (optional) and the
8003 * mechanism kV and kA, specified via the Motion Magic® configuration
8004 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
8005 * configs are always in output units of Volts.
8006 *
8007 * Setting Cruise Velocity to 0 will allow the profile to run to the
8008 * max possible velocity based on Expo_kV. This control mode does not
8009 * use the Acceleration or Jerk configs.
8010 *
8011 * Target position can be changed on-the-fly and Motion Magic® will do
8012 * its best to adjust the profile. This control mode is based on
8013 * torque current, so relevant closed-loop gains will use Amperes for
8014 * the numerator.
8015 *
8016 * - MotionMagicExpoTorqueCurrentFOC Parameters:
8017 * - Position: Position to drive toward in rotations.
8018 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
8019 * added to the output of the onboard feedforward terms.
8020 *
8021 * User can use motor's kT to scale Newton-meter to Amperes.
8022 * - Slot: Select which gains are applied by selecting the slot. Use the
8023 * configuration api to set the gain values for the selected slot
8024 * before enabling this feature. Slot must be within [0,2].
8025 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
8026 * zero (or within deadband). Set to false to use
8027 * the NeutralMode configuration setting (default).
8028 * This flag exists to provide the fundamental
8029 * behavior of this control when output is zero,
8030 * which is to provide 0A (zero torque).
8031 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8032 * users to use other limit switch sensors connected to
8033 * robot controller. This also allows use of active
8034 * sensors that require external power.
8035 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8036 * users to use other limit switch sensors connected to
8037 * robot controller. This also allows use of active
8038 * sensors that require external power.
8039 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8040 * the LimitForwardMotion and LimitReverseMotion
8041 * parameters, instead allowing motion.
8042 *
8043 * This can be useful on mechanisms such as an
8044 * intake/feeder, where a limit switch stops motion
8045 * while intaking but should be ignored when feeding
8046 * to a shooter.
8047 *
8048 * The hardware limit faults and Forward/ReverseLimit
8049 * signals will still report the values of the limit
8050 * switches regardless of this parameter.
8051 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8052 * allowing motion.
8053 *
8054 * This can be useful when calibrating the zero point
8055 * of a mechanism such as an elevator.
8056 *
8057 * The software limit faults will still report the
8058 * values of the software limits regardless of this
8059 * parameter.
8060 * - UseTimesync: Set to true to delay applying this control request until a
8061 * timesync boundary (requires Phoenix Pro and CANivore). This
8062 * eliminates the impact of nondeterministic network delays in
8063 * exchange for a larger but deterministic control latency.
8064 *
8065 * This requires setting the ControlTimesyncFreqHz config in
8066 * MotorOutputConfigs. Additionally, when this is enabled, the
8067 * UpdateFreqHz of this request should be set to 0 Hz.
8068 *
8069 * \param request Control object to request of the device
8070 * \returns Status code of the request
8071 */
8072 ctre::phoenix::StatusCode SetControl(controls::MotionMagicExpoTorqueCurrentFOC const &request) final;
8073
8074 /**
8075 * \brief Requests Motion Magic® to target a final position using a
8076 * motion profile. This dynamic request allows runtime changes to
8077 * Cruise Velocity, Acceleration, and (optional) Jerk. Users can
8078 * optionally provide a duty cycle feedforward.
8079 *
8080 * \details Motion Magic® produces a motion profile in real-time while
8081 * attempting to honor the specified Cruise Velocity, Acceleration,
8082 * and (optional) Jerk. This control mode does not use the Expo_kV or
8083 * Expo_kA configs.
8084 *
8085 * Target position can be changed on-the-fly and Motion Magic® will do
8086 * its best to adjust the profile. This control mode is duty cycle
8087 * based, so relevant closed-loop gains will use fractional duty cycle
8088 * for the numerator: +1.0 represents full forward output.
8089 *
8090 * - DynamicMotionMagicDutyCycle Parameters:
8091 * - Position: Position to drive toward in rotations.
8092 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8093 * the device will use the absolute value for profile generation.
8094 * - Acceleration: Acceleration for profiling. The signage does not matter as
8095 * the device will use the absolute value for profile
8096 * generation
8097 * - Jerk: Jerk for profiling. The signage does not matter as the device will
8098 * use the absolute value for profile generation.
8099 *
8100 * Jerk is optional; if this is set to zero, then Motion Magic® will
8101 * not apply a Jerk limit.
8102 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
8103 * which increases peak power by ~15% on supported devices (see
8104 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
8105 * commutation.
8106 *
8107 * FOC improves motor performance by leveraging torque (current)
8108 * control. However, this may be inconvenient for applications
8109 * that require specifying duty cycle or voltage.
8110 * CTR-Electronics has developed a hybrid method that combines
8111 * the performances gains of FOC while still allowing
8112 * applications to provide duty cycle or voltage demand. This
8113 * not to be confused with simple sinusoidal control or phase
8114 * voltage control which lacks the performance gains.
8115 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
8116 * This is added to the output of the onboard feedforward
8117 * terms.
8118 * - Slot: Select which gains are applied by selecting the slot. Use the
8119 * configuration api to set the gain values for the selected slot
8120 * before enabling this feature. Slot must be within [0,2].
8121 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
8122 * output is zero (or within deadband). Set to
8123 * false to use the NeutralMode configuration
8124 * setting (default). This flag exists to provide
8125 * the fundamental behavior of this control when
8126 * output is zero, which is to provide 0V to the
8127 * motor.
8128 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8129 * users to use other limit switch sensors connected to
8130 * robot controller. This also allows use of active
8131 * sensors that require external power.
8132 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8133 * users to use other limit switch sensors connected to
8134 * robot controller. This also allows use of active
8135 * sensors that require external power.
8136 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8137 * the LimitForwardMotion and LimitReverseMotion
8138 * parameters, instead allowing motion.
8139 *
8140 * This can be useful on mechanisms such as an
8141 * intake/feeder, where a limit switch stops motion
8142 * while intaking but should be ignored when feeding
8143 * to a shooter.
8144 *
8145 * The hardware limit faults and Forward/ReverseLimit
8146 * signals will still report the values of the limit
8147 * switches regardless of this parameter.
8148 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8149 * allowing motion.
8150 *
8151 * This can be useful when calibrating the zero point
8152 * of a mechanism such as an elevator.
8153 *
8154 * The software limit faults will still report the
8155 * values of the software limits regardless of this
8156 * parameter.
8157 * - UseTimesync: Set to true to delay applying this control request until a
8158 * timesync boundary (requires Phoenix Pro and CANivore). This
8159 * eliminates the impact of nondeterministic network delays in
8160 * exchange for a larger but deterministic control latency.
8161 *
8162 * This requires setting the ControlTimesyncFreqHz config in
8163 * MotorOutputConfigs. Additionally, when this is enabled, the
8164 * UpdateFreqHz of this request should be set to 0 Hz.
8165 *
8166 * \param request Control object to request of the device
8167 * \returns Status code of the request
8168 */
8169 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicDutyCycle const &request) final;
8170
8171 /**
8172 * \brief Requests Motion Magic® to target a final position using a
8173 * motion profile. This dynamic request allows runtime changes to
8174 * Cruise Velocity, Acceleration, and (optional) Jerk. Users can
8175 * optionally provide a voltage feedforward.
8176 *
8177 * \details Motion Magic® produces a motion profile in real-time while
8178 * attempting to honor the specified Cruise Velocity, Acceleration,
8179 * and (optional) Jerk. This control mode does not use the Expo_kV or
8180 * Expo_kA configs.
8181 *
8182 * Target position can be changed on-the-fly and Motion Magic® will do
8183 * its best to adjust the profile. This control mode is
8184 * voltage-based, so relevant closed-loop gains will use Volts for the
8185 * numerator.
8186 *
8187 * - DynamicMotionMagicVoltage Parameters:
8188 * - Position: Position to drive toward in rotations.
8189 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8190 * the device will use the absolute value for profile generation.
8191 * - Acceleration: Acceleration for profiling. The signage does not matter as
8192 * the device will use the absolute value for profile
8193 * generation.
8194 * - Jerk: Jerk for profiling. The signage does not matter as the device will
8195 * use the absolute value for profile generation.
8196 *
8197 * Jerk is optional; if this is set to zero, then Motion Magic® will
8198 * not apply a Jerk limit.
8199 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
8200 * which increases peak power by ~15% on supported devices (see
8201 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
8202 * commutation.
8203 *
8204 * FOC improves motor performance by leveraging torque (current)
8205 * control. However, this may be inconvenient for applications
8206 * that require specifying duty cycle or voltage.
8207 * CTR-Electronics has developed a hybrid method that combines
8208 * the performances gains of FOC while still allowing
8209 * applications to provide duty cycle or voltage demand. This
8210 * not to be confused with simple sinusoidal control or phase
8211 * voltage control which lacks the performance gains.
8212 * - FeedForward: Feedforward to apply in volts. This is added to the output
8213 * of the onboard feedforward terms.
8214 * - Slot: Select which gains are applied by selecting the slot. Use the
8215 * configuration api to set the gain values for the selected slot
8216 * before enabling this feature. Slot must be within [0,2].
8217 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
8218 * output is zero (or within deadband). Set to
8219 * false to use the NeutralMode configuration
8220 * setting (default). This flag exists to provide
8221 * the fundamental behavior of this control when
8222 * output is zero, which is to provide 0V to the
8223 * motor.
8224 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8225 * users to use other limit switch sensors connected to
8226 * robot controller. This also allows use of active
8227 * sensors that require external power.
8228 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8229 * users to use other limit switch sensors connected to
8230 * robot controller. This also allows use of active
8231 * sensors that require external power.
8232 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8233 * the LimitForwardMotion and LimitReverseMotion
8234 * parameters, instead allowing motion.
8235 *
8236 * This can be useful on mechanisms such as an
8237 * intake/feeder, where a limit switch stops motion
8238 * while intaking but should be ignored when feeding
8239 * to a shooter.
8240 *
8241 * The hardware limit faults and Forward/ReverseLimit
8242 * signals will still report the values of the limit
8243 * switches regardless of this parameter.
8244 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8245 * allowing motion.
8246 *
8247 * This can be useful when calibrating the zero point
8248 * of a mechanism such as an elevator.
8249 *
8250 * The software limit faults will still report the
8251 * values of the software limits regardless of this
8252 * parameter.
8253 * - UseTimesync: Set to true to delay applying this control request until a
8254 * timesync boundary (requires Phoenix Pro and CANivore). This
8255 * eliminates the impact of nondeterministic network delays in
8256 * exchange for a larger but deterministic control latency.
8257 *
8258 * This requires setting the ControlTimesyncFreqHz config in
8259 * MotorOutputConfigs. Additionally, when this is enabled, the
8260 * UpdateFreqHz of this request should be set to 0 Hz.
8261 *
8262 * \param request Control object to request of the device
8263 * \returns Status code of the request
8264 */
8265 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicVoltage const &request) final;
8266
8267 /**
8268 * \brief Requests Motion Magic® to target a final position using a
8269 * motion profile. This dynamic request allows runtime changes to
8270 * Cruise Velocity, Acceleration, and (optional) Jerk. Users can
8271 * optionally provide a torque current feedforward.
8272 *
8273 * \details Motion Magic® produces a motion profile in real-time while
8274 * attempting to honor the specified Cruise Velocity, Acceleration,
8275 * and (optional) Jerk. This control mode does not use the Expo_kV or
8276 * Expo_kA configs.
8277 *
8278 * Target position can be changed on-the-fly and Motion Magic® will do
8279 * its best to adjust the profile. This control mode is based on
8280 * torque current, so relevant closed-loop gains will use Amperes for
8281 * the numerator.
8282 *
8283 * - DynamicMotionMagicTorqueCurrentFOC Parameters:
8284 * - Position: Position to drive toward in rotations.
8285 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8286 * the device will use the absolute value for profile generation.
8287 * - Acceleration: Acceleration for profiling. The signage does not matter as
8288 * the device will use the absolute value for profile
8289 * generation.
8290 * - Jerk: Jerk for profiling. The signage does not matter as the device will
8291 * use the absolute value for profile generation.
8292 *
8293 * Jerk is optional; if this is set to zero, then Motion Magic® will
8294 * not apply a Jerk limit.
8295 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
8296 * added to the output of the onboard feedforward terms.
8297 *
8298 * User can use motor's kT to scale Newton-meter to Amperes.
8299 * - Slot: Select which gains are applied by selecting the slot. Use the
8300 * configuration api to set the gain values for the selected slot
8301 * before enabling this feature. Slot must be within [0,2].
8302 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
8303 * zero (or within deadband). Set to false to use
8304 * the NeutralMode configuration setting (default).
8305 * This flag exists to provide the fundamental
8306 * behavior of this control when output is zero,
8307 * which is to provide 0A (zero torque).
8308 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8309 * users to use other limit switch sensors connected to
8310 * robot controller. This also allows use of active
8311 * sensors that require external power.
8312 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8313 * users to use other limit switch sensors connected to
8314 * robot controller. This also allows use of active
8315 * sensors that require external power.
8316 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8317 * the LimitForwardMotion and LimitReverseMotion
8318 * parameters, instead allowing motion.
8319 *
8320 * This can be useful on mechanisms such as an
8321 * intake/feeder, where a limit switch stops motion
8322 * while intaking but should be ignored when feeding
8323 * to a shooter.
8324 *
8325 * The hardware limit faults and Forward/ReverseLimit
8326 * signals will still report the values of the limit
8327 * switches regardless of this parameter.
8328 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8329 * allowing motion.
8330 *
8331 * This can be useful when calibrating the zero point
8332 * of a mechanism such as an elevator.
8333 *
8334 * The software limit faults will still report the
8335 * values of the software limits regardless of this
8336 * parameter.
8337 * - UseTimesync: Set to true to delay applying this control request until a
8338 * timesync boundary (requires Phoenix Pro and CANivore). This
8339 * eliminates the impact of nondeterministic network delays in
8340 * exchange for a larger but deterministic control latency.
8341 *
8342 * This requires setting the ControlTimesyncFreqHz config in
8343 * MotorOutputConfigs. Additionally, when this is enabled, the
8344 * UpdateFreqHz of this request should be set to 0 Hz.
8345 *
8346 * \param request Control object to request of the device
8347 * \returns Status code of the request
8348 */
8349 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicTorqueCurrentFOC const &request) final;
8350
8351 /**
8352 * \brief Requests Motion Magic® Expo to target a final position using
8353 * an exponential motion profile. This dynamic request allows runtime
8354 * changes to the profile kV, kA, and (optional) Cruise Velocity.
8355 * Users can optionally provide a duty cycle feedforward.
8356 *
8357 * \details Motion Magic® Expo produces a motion profile in real-time
8358 * while attempting to honor the specified Cruise Velocity (optional)
8359 * and the mechanism kV and kA. Note that unlike the slot gains, the
8360 * Expo_kV and Expo_kA parameters are always in output units of Volts.
8361 *
8362 * Setting the Cruise Velocity to 0 will allow the profile to run to
8363 * the max possible velocity based on Expo_kV. This control mode does
8364 * not use the Acceleration or Jerk configs.
8365 *
8366 * Target position can be changed on-the-fly and Motion Magic® will do
8367 * its best to adjust the profile. This control mode is duty cycle
8368 * based, so relevant closed-loop gains will use fractional duty cycle
8369 * for the numerator: +1.0 represents full forward output.
8370 *
8371 * - DynamicMotionMagicExpoDutyCycle Parameters:
8372 * - Position: Position to drive toward in rotations.
8373 * - kV: Mechanism kV for profiling. Unlike the kV slot gain, this is always
8374 * in units of V/rps.
8375 *
8376 * This represents the amount of voltage necessary to hold a velocity.
8377 * In terms of the Motion Magic® Expo profile, a higher kV results in a
8378 * slower maximum velocity.
8379 * - kA: Mechanism kA for profiling. Unlike the kA slot gain, this is always
8380 * in units of V/rps².
8381 *
8382 * This represents the amount of voltage necessary to achieve an
8383 * acceleration. In terms of the Motion Magic® Expo profile, a higher
8384 * kA results in a slower acceleration.
8385 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8386 * the device will use the absolute value for profile generation.
8387 * Setting this to 0 will allow the profile to run to the max
8388 * possible velocity based on Expo_kV.
8389 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
8390 * which increases peak power by ~15% on supported devices (see
8391 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
8392 * commutation.
8393 *
8394 * FOC improves motor performance by leveraging torque (current)
8395 * control. However, this may be inconvenient for applications
8396 * that require specifying duty cycle or voltage.
8397 * CTR-Electronics has developed a hybrid method that combines
8398 * the performances gains of FOC while still allowing
8399 * applications to provide duty cycle or voltage demand. This
8400 * not to be confused with simple sinusoidal control or phase
8401 * voltage control which lacks the performance gains.
8402 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
8403 * This is added to the output of the onboard feedforward
8404 * terms.
8405 * - Slot: Select which gains are applied by selecting the slot. Use the
8406 * configuration api to set the gain values for the selected slot
8407 * before enabling this feature. Slot must be within [0,2].
8408 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
8409 * output is zero (or within deadband). Set to
8410 * false to use the NeutralMode configuration
8411 * setting (default). This flag exists to provide
8412 * the fundamental behavior of this control when
8413 * output is zero, which is to provide 0V to the
8414 * motor.
8415 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8416 * users to use other limit switch sensors connected to
8417 * robot controller. This also allows use of active
8418 * sensors that require external power.
8419 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8420 * users to use other limit switch sensors connected to
8421 * robot controller. This also allows use of active
8422 * sensors that require external power.
8423 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8424 * the LimitForwardMotion and LimitReverseMotion
8425 * parameters, instead allowing motion.
8426 *
8427 * This can be useful on mechanisms such as an
8428 * intake/feeder, where a limit switch stops motion
8429 * while intaking but should be ignored when feeding
8430 * to a shooter.
8431 *
8432 * The hardware limit faults and Forward/ReverseLimit
8433 * signals will still report the values of the limit
8434 * switches regardless of this parameter.
8435 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8436 * allowing motion.
8437 *
8438 * This can be useful when calibrating the zero point
8439 * of a mechanism such as an elevator.
8440 *
8441 * The software limit faults will still report the
8442 * values of the software limits regardless of this
8443 * parameter.
8444 * - UseTimesync: Set to true to delay applying this control request until a
8445 * timesync boundary (requires Phoenix Pro and CANivore). This
8446 * eliminates the impact of nondeterministic network delays in
8447 * exchange for a larger but deterministic control latency.
8448 *
8449 * This requires setting the ControlTimesyncFreqHz config in
8450 * MotorOutputConfigs. Additionally, when this is enabled, the
8451 * UpdateFreqHz of this request should be set to 0 Hz.
8452 *
8453 * \param request Control object to request of the device
8454 * \returns Status code of the request
8455 */
8456 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicExpoDutyCycle const &request) final;
8457
8458 /**
8459 * \brief Requests Motion Magic® Expo to target a final position using
8460 * an exponential motion profile. This dynamic request allows runtime
8461 * changes to the profile kV, kA, and (optional) Cruise Velocity.
8462 * Users can optionally provide a voltage feedforward.
8463 *
8464 * \details Motion Magic® Expo produces a motion profile in real-time
8465 * while attempting to honor the specified Cruise Velocity (optional)
8466 * and the mechanism kV and kA. Note that unlike the slot gains, the
8467 * Expo_kV and Expo_kA parameters are always in output units of Volts.
8468 *
8469 * Setting the Cruise Velocity to 0 will allow the profile to run to
8470 * the max possible velocity based on Expo_kV. This control mode does
8471 * not use the Acceleration or Jerk configs.
8472 *
8473 * Target position can be changed on-the-fly and Motion Magic® will do
8474 * its best to adjust the profile. This control mode is
8475 * voltage-based, so relevant closed-loop gains will use Volts for the
8476 * numerator.
8477 *
8478 * - DynamicMotionMagicExpoVoltage Parameters:
8479 * - Position: Position to drive toward in rotations.
8480 * - kV: Mechanism kV for profiling. Unlike the kV slot gain, this is always
8481 * in units of V/rps.
8482 *
8483 * This represents the amount of voltage necessary to hold a velocity.
8484 * In terms of the Motion Magic® Expo profile, a higher kV results in a
8485 * slower maximum velocity.
8486 * - kA: Mechanism kA for profiling. Unlike the kA slot gain, this is always
8487 * in units of V/rps².
8488 *
8489 * This represents the amount of voltage necessary to achieve an
8490 * acceleration. In terms of the Motion Magic® Expo profile, a higher
8491 * kA results in a slower acceleration.
8492 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8493 * the device will use the absolute value for profile generation.
8494 * Setting this to 0 will allow the profile to run to the max
8495 * possible velocity based on Expo_kV.
8496 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
8497 * which increases peak power by ~15% on supported devices (see
8498 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
8499 * commutation.
8500 *
8501 * FOC improves motor performance by leveraging torque (current)
8502 * control. However, this may be inconvenient for applications
8503 * that require specifying duty cycle or voltage.
8504 * CTR-Electronics has developed a hybrid method that combines
8505 * the performances gains of FOC while still allowing
8506 * applications to provide duty cycle or voltage demand. This
8507 * not to be confused with simple sinusoidal control or phase
8508 * voltage control which lacks the performance gains.
8509 * - FeedForward: Feedforward to apply in volts. This is added to the output
8510 * of the onboard feedforward terms.
8511 * - Slot: Select which gains are applied by selecting the slot. Use the
8512 * configuration api to set the gain values for the selected slot
8513 * before enabling this feature. Slot must be within [0,2].
8514 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
8515 * output is zero (or within deadband). Set to
8516 * false to use the NeutralMode configuration
8517 * setting (default). This flag exists to provide
8518 * the fundamental behavior of this control when
8519 * output is zero, which is to provide 0V to the
8520 * motor.
8521 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8522 * users to use other limit switch sensors connected to
8523 * robot controller. This also allows use of active
8524 * sensors that require external power.
8525 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8526 * users to use other limit switch sensors connected to
8527 * robot controller. This also allows use of active
8528 * sensors that require external power.
8529 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8530 * the LimitForwardMotion and LimitReverseMotion
8531 * parameters, instead allowing motion.
8532 *
8533 * This can be useful on mechanisms such as an
8534 * intake/feeder, where a limit switch stops motion
8535 * while intaking but should be ignored when feeding
8536 * to a shooter.
8537 *
8538 * The hardware limit faults and Forward/ReverseLimit
8539 * signals will still report the values of the limit
8540 * switches regardless of this parameter.
8541 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8542 * allowing motion.
8543 *
8544 * This can be useful when calibrating the zero point
8545 * of a mechanism such as an elevator.
8546 *
8547 * The software limit faults will still report the
8548 * values of the software limits regardless of this
8549 * parameter.
8550 * - UseTimesync: Set to true to delay applying this control request until a
8551 * timesync boundary (requires Phoenix Pro and CANivore). This
8552 * eliminates the impact of nondeterministic network delays in
8553 * exchange for a larger but deterministic control latency.
8554 *
8555 * This requires setting the ControlTimesyncFreqHz config in
8556 * MotorOutputConfigs. Additionally, when this is enabled, the
8557 * UpdateFreqHz of this request should be set to 0 Hz.
8558 *
8559 * \param request Control object to request of the device
8560 * \returns Status code of the request
8561 */
8562 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicExpoVoltage const &request) final;
8563
8564 /**
8565 * \brief Requests Motion Magic® Expo to target a final position using
8566 * an exponential motion profile. This dynamic request allows runtime
8567 * changes to the profile kV, kA, and (optional) Cruise Velocity.
8568 * Users can optionally provide a torque current feedforward.
8569 *
8570 * \details Motion Magic® Expo produces a motion profile in real-time
8571 * while attempting to honor the specified Cruise Velocity (optional)
8572 * and the mechanism kV and kA. Note that unlike the slot gains, the
8573 * Expo_kV and Expo_kA parameters are always in output units of Volts.
8574 *
8575 * Setting the Cruise Velocity to 0 will allow the profile to run to
8576 * the max possible velocity based on Expo_kV. This control mode does
8577 * not use the Acceleration or Jerk configs.
8578 *
8579 * Target position can be changed on-the-fly and Motion Magic® will do
8580 * its best to adjust the profile. This control mode is based on
8581 * torque current, so relevant closed-loop gains will use Amperes for
8582 * the numerator.
8583 *
8584 * - DynamicMotionMagicExpoTorqueCurrentFOC Parameters:
8585 * - Position: Position to drive toward in rotations.
8586 * - kV: Mechanism kV for profiling. Unlike the kV slot gain, this is always
8587 * in units of V/rps.
8588 *
8589 * This represents the amount of voltage necessary to hold a velocity.
8590 * In terms of the Motion Magic® Expo profile, a higher kV results in a
8591 * slower maximum velocity.
8592 * - kA: Mechanism kA for profiling. Unlike the kA slot gain, this is always
8593 * in units of V/rps².
8594 *
8595 * This represents the amount of voltage necessary to achieve an
8596 * acceleration. In terms of the Motion Magic® Expo profile, a higher
8597 * kA results in a slower acceleration.
8598 * - Velocity: Cruise velocity for profiling. The signage does not matter as
8599 * the device will use the absolute value for profile generation.
8600 * Setting this to 0 will allow the profile to run to the max
8601 * possible velocity based on Expo_kV.
8602 * - FeedForward: Feedforward to apply in torque current in Amperes. This is
8603 * added to the output of the onboard feedforward terms.
8604 *
8605 * User can use motor's kT to scale Newton-meter to Amperes.
8606 * - Slot: Select which gains are applied by selecting the slot. Use the
8607 * configuration api to set the gain values for the selected slot
8608 * before enabling this feature. Slot must be within [0,2].
8609 * - OverrideCoastDurNeutral: Set to true to coast the rotor when output is
8610 * zero (or within deadband). Set to false to use
8611 * the NeutralMode configuration setting (default).
8612 * This flag exists to provide the fundamental
8613 * behavior of this control when output is zero,
8614 * which is to provide 0A (zero torque).
8615 * - LimitForwardMotion: Set to true to force forward limiting. This allows
8616 * users to use other limit switch sensors connected to
8617 * robot controller. This also allows use of active
8618 * sensors that require external power.
8619 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
8620 * users to use other limit switch sensors connected to
8621 * robot controller. This also allows use of active
8622 * sensors that require external power.
8623 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
8624 * the LimitForwardMotion and LimitReverseMotion
8625 * parameters, instead allowing motion.
8626 *
8627 * This can be useful on mechanisms such as an
8628 * intake/feeder, where a limit switch stops motion
8629 * while intaking but should be ignored when feeding
8630 * to a shooter.
8631 *
8632 * The hardware limit faults and Forward/ReverseLimit
8633 * signals will still report the values of the limit
8634 * switches regardless of this parameter.
8635 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
8636 * allowing motion.
8637 *
8638 * This can be useful when calibrating the zero point
8639 * of a mechanism such as an elevator.
8640 *
8641 * The software limit faults will still report the
8642 * values of the software limits regardless of this
8643 * parameter.
8644 * - UseTimesync: Set to true to delay applying this control request until a
8645 * timesync boundary (requires Phoenix Pro and CANivore). This
8646 * eliminates the impact of nondeterministic network delays in
8647 * exchange for a larger but deterministic control latency.
8648 *
8649 * This requires setting the ControlTimesyncFreqHz config in
8650 * MotorOutputConfigs. Additionally, when this is enabled, the
8651 * UpdateFreqHz of this request should be set to 0 Hz.
8652 *
8653 * \param request Control object to request of the device
8654 * \returns Status code of the request
8655 */
8656 ctre::phoenix::StatusCode SetControl(controls::DynamicMotionMagicExpoTorqueCurrentFOC const &request) final;
8657
8658 /**
8659 * \brief Differential control with duty cycle average target and
8660 * position difference target.
8661 *
8662 * - Diff_DutyCycleOut_Position Parameters:
8663 * - AverageRequest: Average DutyCycleOut request of the mechanism.
8664 * - DifferentialRequest: Differential PositionDutyCycle request of the
8665 * mechanism.
8666 *
8667 * \param request Control object to request of the device
8668 * \returns Status code of the request
8669 */
8670 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_DutyCycleOut_Position const &request) final;
8671
8672 /**
8673 * \brief Differential control with position average target and
8674 * position difference target using duty cycle control.
8675 *
8676 * - Diff_PositionDutyCycle_Position Parameters:
8677 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
8678 * - DifferentialRequest: Differential PositionDutyCycle request of the
8679 * mechanism.
8680 *
8681 * \param request Control object to request of the device
8682 * \returns Status code of the request
8683 */
8684 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionDutyCycle_Position const &request) final;
8685
8686 /**
8687 * \brief Differential control with velocity average target and
8688 * position difference target using duty cycle control.
8689 *
8690 * - Diff_VelocityDutyCycle_Position Parameters:
8691 * - AverageRequest: Average VelocityDutyCYcle request of the mechanism.
8692 * - DifferentialRequest: Differential PositionDutyCycle request of the
8693 * mechanism.
8694 *
8695 * \param request Control object to request of the device
8696 * \returns Status code of the request
8697 */
8698 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityDutyCycle_Position const &request) final;
8699
8700 /**
8701 * \brief Differential control with Motion Magic® average target and
8702 * position difference target using duty cycle control.
8703 *
8704 * - Diff_MotionMagicDutyCycle_Position Parameters:
8705 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
8706 * - DifferentialRequest: Differential PositionDutyCycle request of the
8707 * mechanism.
8708 *
8709 * \param request Control object to request of the device
8710 * \returns Status code of the request
8711 */
8712 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicDutyCycle_Position const &request) final;
8713
8714 /**
8715 * \brief Differential control with Motion Magic® Expo average target
8716 * and position difference target using duty cycle control.
8717 *
8718 * - Diff_MotionMagicExpoDutyCycle_Position Parameters:
8719 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
8720 * mechanism.
8721 * - DifferentialRequest: Differential PositionDutyCycle request of the
8722 * mechanism.
8723 *
8724 * \param request Control object to request of the device
8725 * \returns Status code of the request
8726 */
8727 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoDutyCycle_Position const &request) final;
8728
8729 /**
8730 * \brief Differential control with Motion Magic® Velocity average
8731 * target and position difference target using duty cycle control.
8732 *
8733 * - Diff_MotionMagicVelocityDutyCycle_Position Parameters:
8734 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
8735 * mechanism.
8736 * - DifferentialRequest: Differential PositionDutyCycle request of the
8737 * mechanism.
8738 *
8739 * \param request Control object to request of the device
8740 * \returns Status code of the request
8741 */
8742 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityDutyCycle_Position const &request) final;
8743
8744 /**
8745 * \brief Differential control with duty cycle average target and
8746 * velocity difference target.
8747 *
8748 * - Diff_DutyCycleOut_Velocity Parameters:
8749 * - AverageRequest: Average DutyCycleOut request of the mechanism.
8750 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8751 * mechanism.
8752 *
8753 * \param request Control object to request of the device
8754 * \returns Status code of the request
8755 */
8756 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_DutyCycleOut_Velocity const &request) final;
8757
8758 /**
8759 * \brief Differential control with position average target and
8760 * velocity difference target using duty cycle control.
8761 *
8762 * - Diff_PositionDutyCycle_Velocity Parameters:
8763 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
8764 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8765 * mechanism.
8766 *
8767 * \param request Control object to request of the device
8768 * \returns Status code of the request
8769 */
8770 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionDutyCycle_Velocity const &request) final;
8771
8772 /**
8773 * \brief Differential control with velocity average target and
8774 * velocity difference target using duty cycle control.
8775 *
8776 * - Diff_VelocityDutyCycle_Velocity Parameters:
8777 * - AverageRequest: Average VelocityDutyCycle request of the mechanism.
8778 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8779 * mechanism.
8780 *
8781 * \param request Control object to request of the device
8782 * \returns Status code of the request
8783 */
8784 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityDutyCycle_Velocity const &request) final;
8785
8786 /**
8787 * \brief Differential control with Motion Magic® average target and
8788 * velocity difference target using duty cycle control.
8789 *
8790 * - Diff_MotionMagicDutyCycle_Velocity Parameters:
8791 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
8792 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8793 * mechanism.
8794 *
8795 * \param request Control object to request of the device
8796 * \returns Status code of the request
8797 */
8798 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicDutyCycle_Velocity const &request) final;
8799
8800 /**
8801 * \brief Differential control with Motion Magic® Expo average target
8802 * and velocity difference target using duty cycle control.
8803 *
8804 * - Diff_MotionMagicExpoDutyCycle_Velocity Parameters:
8805 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
8806 * mechanism.
8807 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8808 * mechanism.
8809 *
8810 * \param request Control object to request of the device
8811 * \returns Status code of the request
8812 */
8813 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoDutyCycle_Velocity const &request) final;
8814
8815 /**
8816 * \brief Differential control with Motion Magic® Velocity average
8817 * target and velocity difference target using duty cycle control.
8818 *
8819 * - Diff_MotionMagicVelocityDutyCycle_Velocity Parameters:
8820 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
8821 * mechanism.
8822 * - DifferentialRequest: Differential VelocityDutyCycle request of the
8823 * mechanism.
8824 *
8825 * \param request Control object to request of the device
8826 * \returns Status code of the request
8827 */
8828 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityDutyCycle_Velocity const &request) final;
8829
8830 /**
8831 * \brief Differential control with duty cycle average target and duty
8832 * cycle difference target.
8833 *
8834 * - Diff_DutyCycleOut_Open Parameters:
8835 * - AverageRequest: Average DutyCycleOut request of the mechanism.
8836 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8837 *
8838 * \param request Control object to request of the device
8839 * \returns Status code of the request
8840 */
8841 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_DutyCycleOut_Open const &request) final;
8842
8843 /**
8844 * \brief Differential control with position average target and duty
8845 * cycle difference target.
8846 *
8847 * - Diff_PositionDutyCycle_Open Parameters:
8848 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
8849 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8850 *
8851 * \param request Control object to request of the device
8852 * \returns Status code of the request
8853 */
8854 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionDutyCycle_Open const &request) final;
8855
8856 /**
8857 * \brief Differential control with velocity average target and duty
8858 * cycle difference target.
8859 *
8860 * - Diff_VelocityDutyCycle_Open Parameters:
8861 * - AverageRequest: Average VelocityDutyCYcle request of the mechanism.
8862 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8863 *
8864 * \param request Control object to request of the device
8865 * \returns Status code of the request
8866 */
8867 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityDutyCycle_Open const &request) final;
8868
8869 /**
8870 * \brief Differential control with Motion Magic® average target and
8871 * duty cycle difference target.
8872 *
8873 * - Diff_MotionMagicDutyCycle_Open Parameters:
8874 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
8875 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8876 *
8877 * \param request Control object to request of the device
8878 * \returns Status code of the request
8879 */
8880 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicDutyCycle_Open const &request) final;
8881
8882 /**
8883 * \brief Differential control with Motion Magic® Expo average target
8884 * and duty cycle difference target.
8885 *
8886 * - Diff_MotionMagicExpoDutyCycle_Open Parameters:
8887 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
8888 * mechanism.
8889 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8890 *
8891 * \param request Control object to request of the device
8892 * \returns Status code of the request
8893 */
8894 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoDutyCycle_Open const &request) final;
8895
8896 /**
8897 * \brief Differential control with Motion Magic® Velocity average
8898 * target and duty cycle difference target.
8899 *
8900 * - Diff_MotionMagicVelocityDutyCycle_Open Parameters:
8901 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
8902 * mechanism.
8903 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
8904 *
8905 * \param request Control object to request of the device
8906 * \returns Status code of the request
8907 */
8908 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityDutyCycle_Open const &request) final;
8909
8910 /**
8911 * \brief Differential control with voltage average target and
8912 * position difference target.
8913 *
8914 * - Diff_VoltageOut_Position Parameters:
8915 * - AverageRequest: Average VoltageOut request of the mechanism.
8916 * - DifferentialRequest: Differential PositionVoltage request of the
8917 * mechanism.
8918 *
8919 * \param request Control object to request of the device
8920 * \returns Status code of the request
8921 */
8922 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VoltageOut_Position const &request) final;
8923
8924 /**
8925 * \brief Differential control with position average target and
8926 * position difference target using voltage control.
8927 *
8928 * - Diff_PositionVoltage_Position Parameters:
8929 * - AverageRequest: Average PositionVoltage request of the mechanism.
8930 * - DifferentialRequest: Differential PositionVoltage request of the
8931 * mechanism.
8932 *
8933 * \param request Control object to request of the device
8934 * \returns Status code of the request
8935 */
8936 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionVoltage_Position const &request) final;
8937
8938 /**
8939 * \brief Differential control with velocity average target and
8940 * position difference target using voltage control.
8941 *
8942 * - Diff_VelocityVoltage_Position Parameters:
8943 * - AverageRequest: Average VelocityVoltage request of the mechanism.
8944 * - DifferentialRequest: Differential PositionVoltage request of the
8945 * mechanism.
8946 *
8947 * \param request Control object to request of the device
8948 * \returns Status code of the request
8949 */
8950 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityVoltage_Position const &request) final;
8951
8952 /**
8953 * \brief Differential control with Motion Magic® average target and
8954 * position difference target using voltage control.
8955 *
8956 * - Diff_MotionMagicVoltage_Position Parameters:
8957 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
8958 * - DifferentialRequest: Differential PositionVoltage request of the
8959 * mechanism.
8960 *
8961 * \param request Control object to request of the device
8962 * \returns Status code of the request
8963 */
8964 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVoltage_Position const &request) final;
8965
8966 /**
8967 * \brief Differential control with Motion Magic® Expo average target
8968 * and position difference target using voltage control.
8969 *
8970 * - Diff_MotionMagicExpoVoltage_Position Parameters:
8971 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
8972 * - DifferentialRequest: Differential PositionVoltage request of the
8973 * mechanism.
8974 *
8975 * \param request Control object to request of the device
8976 * \returns Status code of the request
8977 */
8978 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoVoltage_Position const &request) final;
8979
8980 /**
8981 * \brief Differential control with Motion Magic® Velocity average
8982 * target and position difference target using voltage control.
8983 *
8984 * - Diff_MotionMagicVelocityVoltage_Position Parameters:
8985 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
8986 * mechanism.
8987 * - DifferentialRequest: Differential PositionVoltage request of the
8988 * mechanism.
8989 *
8990 * \param request Control object to request of the device
8991 * \returns Status code of the request
8992 */
8993 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityVoltage_Position const &request) final;
8994
8995 /**
8996 * \brief Differential control with voltage average target and
8997 * velocity difference target.
8998 *
8999 * - Diff_VoltageOut_Velocity Parameters:
9000 * - AverageRequest: Average VoltageOut request of the mechanism.
9001 * - DifferentialRequest: Differential VelocityVoltage request of the
9002 * mechanism.
9003 *
9004 * \param request Control object to request of the device
9005 * \returns Status code of the request
9006 */
9007 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VoltageOut_Velocity const &request) final;
9008
9009 /**
9010 * \brief Differential control with position average target and
9011 * velocity difference target using voltage control.
9012 *
9013 * - Diff_PositionVoltage_Velocity Parameters:
9014 * - AverageRequest: Average PositionVoltage request of the mechanism.
9015 * - DifferentialRequest: Differential VelocityVoltage request of the
9016 * mechanism.
9017 *
9018 * \param request Control object to request of the device
9019 * \returns Status code of the request
9020 */
9021 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionVoltage_Velocity const &request) final;
9022
9023 /**
9024 * \brief Differential control with velocity average target and
9025 * velocity difference target using voltage control.
9026 *
9027 * - Diff_VelocityVoltage_Velocity Parameters:
9028 * - AverageRequest: Average VelocityVoltage request of the mechanism.
9029 * - DifferentialRequest: Differential VelocityVoltage request of the
9030 * mechanism.
9031 *
9032 * \param request Control object to request of the device
9033 * \returns Status code of the request
9034 */
9035 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityVoltage_Velocity const &request) final;
9036
9037 /**
9038 * \brief Differential control with Motion Magic® average target and
9039 * velocity difference target using voltage control.
9040 *
9041 * - Diff_MotionMagicVoltage_Velocity Parameters:
9042 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
9043 * - DifferentialRequest: Differential VelocityVoltage request of the
9044 * mechanism.
9045 *
9046 * \param request Control object to request of the device
9047 * \returns Status code of the request
9048 */
9049 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVoltage_Velocity const &request) final;
9050
9051 /**
9052 * \brief Differential control with Motion Magic® Expo average target
9053 * and velocity difference target using voltage control.
9054 *
9055 * - Diff_MotionMagicExpoVoltage_Velocity Parameters:
9056 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
9057 * - DifferentialRequest: Differential VelocityVoltage request of the
9058 * mechanism.
9059 *
9060 * \param request Control object to request of the device
9061 * \returns Status code of the request
9062 */
9063 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoVoltage_Velocity const &request) final;
9064
9065 /**
9066 * \brief Differential control with Motion Magic® Velocity average
9067 * target and velocity difference target using voltage control.
9068 *
9069 * - Diff_MotionMagicVelocityVoltage_Velocity Parameters:
9070 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
9071 * mechanism.
9072 * - DifferentialRequest: Differential VelocityVoltage request of the
9073 * mechanism.
9074 *
9075 * \param request Control object to request of the device
9076 * \returns Status code of the request
9077 */
9078 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityVoltage_Velocity const &request) final;
9079
9080 /**
9081 * \brief Differential control with voltage average target and voltage
9082 * difference target.
9083 *
9084 * - Diff_VoltageOut_Open Parameters:
9085 * - AverageRequest: Average VoltageOut request of the mechanism.
9086 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9087 *
9088 * \param request Control object to request of the device
9089 * \returns Status code of the request
9090 */
9091 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VoltageOut_Open const &request) final;
9092
9093 /**
9094 * \brief Differential control with position average target and
9095 * voltage difference target.
9096 *
9097 * - Diff_PositionVoltage_Open Parameters:
9098 * - AverageRequest: Average PositionVoltage request of the mechanism.
9099 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9100 *
9101 * \param request Control object to request of the device
9102 * \returns Status code of the request
9103 */
9104 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionVoltage_Open const &request) final;
9105
9106 /**
9107 * \brief Differential control with velocity average target and
9108 * voltage difference target.
9109 *
9110 * - Diff_VelocityVoltage_Open Parameters:
9111 * - AverageRequest: Average VelocityVoltage request of the mechanism.
9112 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9113 *
9114 * \param request Control object to request of the device
9115 * \returns Status code of the request
9116 */
9117 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityVoltage_Open const &request) final;
9118
9119 /**
9120 * \brief Differential control with Motion Magic® average target and
9121 * voltage difference target.
9122 *
9123 * - Diff_MotionMagicVoltage_Open Parameters:
9124 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
9125 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9126 *
9127 * \param request Control object to request of the device
9128 * \returns Status code of the request
9129 */
9130 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVoltage_Open const &request) final;
9131
9132 /**
9133 * \brief Differential control with Motion Magic® Expo average target
9134 * and voltage difference target.
9135 *
9136 * - Diff_MotionMagicExpoVoltage_Open Parameters:
9137 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
9138 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9139 *
9140 * \param request Control object to request of the device
9141 * \returns Status code of the request
9142 */
9143 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoVoltage_Open const &request) final;
9144
9145 /**
9146 * \brief Differential control with Motion Magic® Velocity average
9147 * target and voltage difference target.
9148 *
9149 * - Diff_MotionMagicVelocityVoltage_Open Parameters:
9150 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
9151 * mechanism.
9152 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
9153 *
9154 * \param request Control object to request of the device
9155 * \returns Status code of the request
9156 */
9157 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityVoltage_Open const &request) final;
9158
9159 /**
9160 * \brief Differential control with torque current average target and
9161 * position difference target.
9162 *
9163 * - Diff_TorqueCurrentFOC_Position Parameters:
9164 * - AverageRequest: Average TorqueCurrentFOC request of the mechanism.
9165 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9166 * mechanism.
9167 *
9168 * \param request Control object to request of the device
9169 * \returns Status code of the request
9170 */
9171 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_TorqueCurrentFOC_Position const &request) final;
9172
9173 /**
9174 * \brief Differential control with position average target and
9175 * position difference target using torque current control.
9176 *
9177 * - Diff_PositionTorqueCurrentFOC_Position Parameters:
9178 * - AverageRequest: Average PositionTorqueCurrentFOC request of the
9179 * mechanism.
9180 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9181 * mechanism.
9182 *
9183 * \param request Control object to request of the device
9184 * \returns Status code of the request
9185 */
9186 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionTorqueCurrentFOC_Position const &request) final;
9187
9188 /**
9189 * \brief Differential control with velocity average target and
9190 * position difference target using torque current control.
9191 *
9192 * - Diff_VelocityTorqueCurrentFOC_Position Parameters:
9193 * - AverageRequest: Average VelocityTorqueCurrentFOC request of the
9194 * mechanism.
9195 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9196 * mechanism.
9197 *
9198 * \param request Control object to request of the device
9199 * \returns Status code of the request
9200 */
9201 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityTorqueCurrentFOC_Position const &request) final;
9202
9203 /**
9204 * \brief Differential control with Motion Magic® average target and
9205 * position difference target using torque current control.
9206 *
9207 * - Diff_MotionMagicTorqueCurrentFOC_Position Parameters:
9208 * - AverageRequest: Average MotionMagicTorqueCurrentFOC request of the
9209 * mechanism.
9210 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9211 * mechanism.
9212 *
9213 * \param request Control object to request of the device
9214 * \returns Status code of the request
9215 */
9216 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicTorqueCurrentFOC_Position const &request) final;
9217
9218 /**
9219 * \brief Differential control with Motion Magic® Expo average target
9220 * and position difference target using torque current control.
9221 *
9222 * - Diff_MotionMagicExpoTorqueCurrentFOC_Position Parameters:
9223 * - AverageRequest: Average MotionMagicExpoTorqueCurrentFOC request of the
9224 * mechanism.
9225 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9226 * mechanism.
9227 *
9228 * \param request Control object to request of the device
9229 * \returns Status code of the request
9230 */
9231 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoTorqueCurrentFOC_Position const &request) final;
9232
9233 /**
9234 * \brief Differential control with Motion Magic® Velocity average
9235 * target and position difference target using torque current control.
9236 *
9237 * - Diff_MotionMagicVelocityTorqueCurrentFOC_Position Parameters:
9238 * - AverageRequest: Average MotionMagicVelocityTorqueCurrentFOC request of
9239 * the mechanism.
9240 * - DifferentialRequest: Differential PositionTorqueCurrentFOC request of the
9241 * mechanism.
9242 *
9243 * \param request Control object to request of the device
9244 * \returns Status code of the request
9245 */
9246 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityTorqueCurrentFOC_Position const &request) final;
9247
9248 /**
9249 * \brief Differential control with torque current average target and
9250 * velocity difference target.
9251 *
9252 * - Diff_TorqueCurrentFOC_Velocity Parameters:
9253 * - AverageRequest: Average TorqueCurrentFOC request of the mechanism.
9254 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9255 * mechanism.
9256 *
9257 * \param request Control object to request of the device
9258 * \returns Status code of the request
9259 */
9260 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_TorqueCurrentFOC_Velocity const &request) final;
9261
9262 /**
9263 * \brief Differential control with position average target and
9264 * velocity difference target using torque current control.
9265 *
9266 * - Diff_PositionTorqueCurrentFOC_Velocity Parameters:
9267 * - AverageRequest: Average PositionTorqueCurrentFOC request of the
9268 * mechanism.
9269 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9270 * mechanism.
9271 *
9272 * \param request Control object to request of the device
9273 * \returns Status code of the request
9274 */
9275 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionTorqueCurrentFOC_Velocity const &request) final;
9276
9277 /**
9278 * \brief Differential control with velocity average target and
9279 * velocity difference target using torque current control.
9280 *
9281 * - Diff_VelocityTorqueCurrentFOC_Velocity Parameters:
9282 * - AverageRequest: Average VelocityTorqueCurrentFOC request of the
9283 * mechanism.
9284 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9285 * mechanism.
9286 *
9287 * \param request Control object to request of the device
9288 * \returns Status code of the request
9289 */
9290 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityTorqueCurrentFOC_Velocity const &request) final;
9291
9292 /**
9293 * \brief Differential control with Motion Magic® average target and
9294 * velocity difference target using torque current control.
9295 *
9296 * - Diff_MotionMagicTorqueCurrentFOC_Velocity Parameters:
9297 * - AverageRequest: Average MotionMagicTorqueCurrentFOC request of the
9298 * mechanism.
9299 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9300 * mechanism.
9301 *
9302 * \param request Control object to request of the device
9303 * \returns Status code of the request
9304 */
9305 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicTorqueCurrentFOC_Velocity const &request) final;
9306
9307 /**
9308 * \brief Differential control with Motion Magic® Expo average target
9309 * and velocity difference target using torque current control.
9310 *
9311 * - Diff_MotionMagicExpoTorqueCurrentFOC_Velocity Parameters:
9312 * - AverageRequest: Average MotionMagicExpoTorqueCurrentFOC request of the
9313 * mechanism.
9314 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9315 * mechanism.
9316 *
9317 * \param request Control object to request of the device
9318 * \returns Status code of the request
9319 */
9320 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoTorqueCurrentFOC_Velocity const &request) final;
9321
9322 /**
9323 * \brief Differential control with Motion Magic® Velocity average
9324 * target and velocity difference target using torque current control.
9325 *
9326 * - Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity Parameters:
9327 * - AverageRequest: Average MotionMagicVelocityTorqueCurrentFOC request of
9328 * the mechanism.
9329 * - DifferentialRequest: Differential VelocityTorqueCurrentFOC request of the
9330 * mechanism.
9331 *
9332 * \param request Control object to request of the device
9333 * \returns Status code of the request
9334 */
9335 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity const &request) final;
9336
9337 /**
9338 * \brief Differential control with torque current average target and
9339 * torque current difference target.
9340 *
9341 * - Diff_TorqueCurrentFOC_Open Parameters:
9342 * - AverageRequest: Average TorqueCurrentFOC request of the mechanism.
9343 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9344 * mechanism.
9345 *
9346 * \param request Control object to request of the device
9347 * \returns Status code of the request
9348 */
9349 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_TorqueCurrentFOC_Open const &request) final;
9350
9351 /**
9352 * \brief Differential control with position average target and torque
9353 * current difference target.
9354 *
9355 * - Diff_PositionTorqueCurrentFOC_Open Parameters:
9356 * - AverageRequest: Average PositionTorqueCurrentFOC request of the
9357 * mechanism.
9358 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9359 * mechanism.
9360 *
9361 * \param request Control object to request of the device
9362 * \returns Status code of the request
9363 */
9364 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_PositionTorqueCurrentFOC_Open const &request) final;
9365
9366 /**
9367 * \brief Differential control with velocity average target and torque
9368 * current difference target.
9369 *
9370 * - Diff_VelocityTorqueCurrentFOC_Open Parameters:
9371 * - AverageRequest: Average VelocityTorqueCurrentFOC request of the
9372 * mechanism.
9373 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9374 * mechanism.
9375 *
9376 * \param request Control object to request of the device
9377 * \returns Status code of the request
9378 */
9379 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_VelocityTorqueCurrentFOC_Open const &request) final;
9380
9381 /**
9382 * \brief Differential control with Motion Magic® average target and
9383 * torque current difference target.
9384 *
9385 * - Diff_MotionMagicTorqueCurrentFOC_Open Parameters:
9386 * - AverageRequest: Average MotionMagicTorqueCurrentFOC request of the
9387 * mechanism.
9388 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9389 * mechanism.
9390 *
9391 * \param request Control object to request of the device
9392 * \returns Status code of the request
9393 */
9394 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicTorqueCurrentFOC_Open const &request) final;
9395
9396 /**
9397 * \brief Differential control with Motion Magic® Expo average target
9398 * and torque current difference target.
9399 *
9400 * - Diff_MotionMagicExpoTorqueCurrentFOC_Open Parameters:
9401 * - AverageRequest: Average MotionMagicExpoTorqueCurrentFOC request of the
9402 * mechanism.
9403 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9404 * mechanism.
9405 *
9406 * \param request Control object to request of the device
9407 * \returns Status code of the request
9408 */
9409 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicExpoTorqueCurrentFOC_Open const &request) final;
9410
9411 /**
9412 * \brief Differential control with Motion Magic® Velocity average
9413 * target and torque current difference target.
9414 *
9415 * - Diff_MotionMagicVelocityTorqueCurrentFOC_Open Parameters:
9416 * - AverageRequest: Average MotionMagicVelocityTorqueCurrentFOC request of
9417 * the mechanism.
9418 * - DifferentialRequest: Differential TorqueCurrentFOC request of the
9419 * mechanism.
9420 *
9421 * \param request Control object to request of the device
9422 * \returns Status code of the request
9423 */
9424 ctre::phoenix::StatusCode SetControl(controls::compound::Diff_MotionMagicVelocityTorqueCurrentFOC_Open const &request) final;
9425
9426 /**
9427 * \brief Apply a generic empty control used to do nothing.
9428 *
9429 * \param request Control object to request of the device
9430 * \returns Status code of the request
9431 */
9432 ctre::phoenix::StatusCode SetControl(controls::EmptyControl const &request) final;
9433
9434 /**
9435 * \brief Control device with generic control request object. User must make
9436 * sure the specified object is castable to a valid control request,
9437 * otherwise this function will fail at run-time and return the NotSupported
9438 * StatusCode
9439 *
9440 * \param request Control object to request of the device
9441 * \returns Status code of the request
9442 */
9443 ctre::phoenix::StatusCode SetControl(controls::ControlRequest const &request) final;
9444
9445
9446 /**
9447 * \brief Sets the mechanism position of the device in mechanism
9448 * rotations.
9449 *
9450 * \param newValue Value to set to. Units are in rotations.
9451 * \param timeoutSeconds Maximum time to wait up to in seconds.
9452 * \returns StatusCode of the set command
9453 */
9454 ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue, units::time::second_t timeoutSeconds) final
9455 {
9456 return GetConfigurator().SetPosition(newValue, timeoutSeconds);
9457 }
9458 /**
9459 * \brief Sets the mechanism position of the device in mechanism
9460 * rotations.
9461 *
9462 * This will wait up to 0.100 seconds (100ms) by default.
9463 *
9464 * \param newValue Value to set to. Units are in rotations.
9465 * \returns StatusCode of the set command
9466 */
9467 ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue) final
9468 {
9469 return SetPosition(newValue, 0.100_s);
9470 }
9471
9472 /**
9473 * \brief Clear the sticky faults in the device.
9474 *
9475 * \details This typically has no impact on the device functionality.
9476 * Instead, it just clears telemetry faults that are accessible via
9477 * API and Tuner Self-Test.
9478 *
9479 * \param timeoutSeconds Maximum time to wait up to in seconds.
9480 * \returns StatusCode of the set command
9481 */
9482 ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds) final
9483 {
9484 return GetConfigurator().ClearStickyFaults(timeoutSeconds);
9485 }
9486 /**
9487 * \brief Clear the sticky faults in the device.
9488 *
9489 * \details This typically has no impact on the device functionality.
9490 * Instead, it just clears telemetry faults that are accessible via
9491 * API and Tuner Self-Test.
9492 *
9493 * This will wait up to 0.100 seconds (100ms) by default.
9494 *
9495 * \returns StatusCode of the set command
9496 */
9497 ctre::phoenix::StatusCode ClearStickyFaults() final
9498 {
9499 return ClearStickyFaults(0.100_s);
9500 }
9501
9502 /**
9503 * \brief Clear sticky fault: Hardware fault occurred
9504 *
9505 * \param timeoutSeconds Maximum time to wait up to in seconds.
9506 * \returns StatusCode of the set command
9507 */
9508 ctre::phoenix::StatusCode ClearStickyFault_Hardware(units::time::second_t timeoutSeconds) final
9509 {
9510 return GetConfigurator().ClearStickyFault_Hardware(timeoutSeconds);
9511 }
9512 /**
9513 * \brief Clear sticky fault: Hardware fault occurred
9514 *
9515 * This will wait up to 0.100 seconds (100ms) by default.
9516 *
9517 * \returns StatusCode of the set command
9518 */
9519 ctre::phoenix::StatusCode ClearStickyFault_Hardware() final
9520 {
9521 return ClearStickyFault_Hardware(0.100_s);
9522 }
9523
9524 /**
9525 * \brief Clear sticky fault: Processor temperature exceeded limit
9526 *
9527 * \param timeoutSeconds Maximum time to wait up to in seconds.
9528 * \returns StatusCode of the set command
9529 */
9530 ctre::phoenix::StatusCode ClearStickyFault_ProcTemp(units::time::second_t timeoutSeconds) final
9531 {
9532 return GetConfigurator().ClearStickyFault_ProcTemp(timeoutSeconds);
9533 }
9534 /**
9535 * \brief Clear sticky fault: Processor temperature exceeded limit
9536 *
9537 * This will wait up to 0.100 seconds (100ms) by default.
9538 *
9539 * \returns StatusCode of the set command
9540 */
9541 ctre::phoenix::StatusCode ClearStickyFault_ProcTemp() final
9542 {
9543 return ClearStickyFault_ProcTemp(0.100_s);
9544 }
9545
9546 /**
9547 * \brief Clear sticky fault: Device temperature exceeded limit
9548 *
9549 * \param timeoutSeconds Maximum time to wait up to in seconds.
9550 * \returns StatusCode of the set command
9551 */
9552 ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp(units::time::second_t timeoutSeconds) final
9553 {
9554 return GetConfigurator().ClearStickyFault_DeviceTemp(timeoutSeconds);
9555 }
9556 /**
9557 * \brief Clear sticky fault: Device temperature exceeded limit
9558 *
9559 * This will wait up to 0.100 seconds (100ms) by default.
9560 *
9561 * \returns StatusCode of the set command
9562 */
9563 ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp() final
9564 {
9565 return ClearStickyFault_DeviceTemp(0.100_s);
9566 }
9567
9568 /**
9569 * \brief Clear sticky fault: Device supply voltage dropped to near
9570 * brownout levels
9571 *
9572 * \param timeoutSeconds Maximum time to wait up to in seconds.
9573 * \returns StatusCode of the set command
9574 */
9575 ctre::phoenix::StatusCode ClearStickyFault_Undervoltage(units::time::second_t timeoutSeconds) final
9576 {
9577 return GetConfigurator().ClearStickyFault_Undervoltage(timeoutSeconds);
9578 }
9579 /**
9580 * \brief Clear sticky fault: Device supply voltage dropped to near
9581 * brownout levels
9582 *
9583 * This will wait up to 0.100 seconds (100ms) by default.
9584 *
9585 * \returns StatusCode of the set command
9586 */
9587 ctre::phoenix::StatusCode ClearStickyFault_Undervoltage() final
9588 {
9589 return ClearStickyFault_Undervoltage(0.100_s);
9590 }
9591
9592 /**
9593 * \brief Clear sticky fault: Device boot while detecting the enable
9594 * signal
9595 *
9596 * \param timeoutSeconds Maximum time to wait up to in seconds.
9597 * \returns StatusCode of the set command
9598 */
9599 ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable(units::time::second_t timeoutSeconds) final
9600 {
9601 return GetConfigurator().ClearStickyFault_BootDuringEnable(timeoutSeconds);
9602 }
9603 /**
9604 * \brief Clear sticky fault: Device boot while detecting the enable
9605 * signal
9606 *
9607 * This will wait up to 0.100 seconds (100ms) by default.
9608 *
9609 * \returns StatusCode of the set command
9610 */
9611 ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable() final
9612 {
9613 return ClearStickyFault_BootDuringEnable(0.100_s);
9614 }
9615
9616 /**
9617 * \brief Clear sticky fault: An unlicensed feature is in use, device
9618 * may not behave as expected.
9619 *
9620 * \param timeoutSeconds Maximum time to wait up to in seconds.
9621 * \returns StatusCode of the set command
9622 */
9623 ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse(units::time::second_t timeoutSeconds) final
9624 {
9625 return GetConfigurator().ClearStickyFault_UnlicensedFeatureInUse(timeoutSeconds);
9626 }
9627 /**
9628 * \brief Clear sticky fault: An unlicensed feature is in use, device
9629 * may not behave as expected.
9630 *
9631 * This will wait up to 0.100 seconds (100ms) by default.
9632 *
9633 * \returns StatusCode of the set command
9634 */
9635 ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse() final
9636 {
9637 return ClearStickyFault_UnlicensedFeatureInUse(0.100_s);
9638 }
9639
9640 /**
9641 * \brief Clear sticky fault: Bridge was disabled most likely due to
9642 * supply voltage dropping too low.
9643 *
9644 * \param timeoutSeconds Maximum time to wait up to in seconds.
9645 * \returns StatusCode of the set command
9646 */
9647 ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout(units::time::second_t timeoutSeconds) final
9648 {
9649 return GetConfigurator().ClearStickyFault_BridgeBrownout(timeoutSeconds);
9650 }
9651 /**
9652 * \brief Clear sticky fault: Bridge was disabled most likely due to
9653 * supply voltage dropping too low.
9654 *
9655 * This will wait up to 0.100 seconds (100ms) by default.
9656 *
9657 * \returns StatusCode of the set command
9658 */
9659 ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout() final
9660 {
9661 return ClearStickyFault_BridgeBrownout(0.100_s);
9662 }
9663
9664 /**
9665 * \brief Clear sticky fault: The remote sensor has reset.
9666 *
9667 * \param timeoutSeconds Maximum time to wait up to in seconds.
9668 * \returns StatusCode of the set command
9669 */
9670 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset(units::time::second_t timeoutSeconds) final
9671 {
9672 return GetConfigurator().ClearStickyFault_RemoteSensorReset(timeoutSeconds);
9673 }
9674 /**
9675 * \brief Clear sticky fault: The remote sensor has reset.
9676 *
9677 * This will wait up to 0.100 seconds (100ms) by default.
9678 *
9679 * \returns StatusCode of the set command
9680 */
9681 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset() final
9682 {
9683 return ClearStickyFault_RemoteSensorReset(0.100_s);
9684 }
9685
9686 /**
9687 * \brief Clear sticky fault: The remote Talon used for differential
9688 * control is not present on CAN Bus.
9689 *
9690 * \param timeoutSeconds Maximum time to wait up to in seconds.
9691 * \returns StatusCode of the set command
9692 */
9693 ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX(units::time::second_t timeoutSeconds) final
9694 {
9695 return GetConfigurator().ClearStickyFault_MissingDifferentialFX(timeoutSeconds);
9696 }
9697 /**
9698 * \brief Clear sticky fault: The remote Talon used for differential
9699 * control is not present on CAN Bus.
9700 *
9701 * This will wait up to 0.100 seconds (100ms) by default.
9702 *
9703 * \returns StatusCode of the set command
9704 */
9705 ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX() final
9706 {
9707 return ClearStickyFault_MissingDifferentialFX(0.100_s);
9708 }
9709
9710 /**
9711 * \brief Clear sticky fault: The remote sensor position has
9712 * overflowed. Because of the nature of remote sensors, it is possible
9713 * for the remote sensor position to overflow beyond what is supported
9714 * by the status signal frame. However, this is rare and cannot occur
9715 * over the course of an FRC match under normal use.
9716 *
9717 * \param timeoutSeconds Maximum time to wait up to in seconds.
9718 * \returns StatusCode of the set command
9719 */
9720 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow(units::time::second_t timeoutSeconds) final
9721 {
9722 return GetConfigurator().ClearStickyFault_RemoteSensorPosOverflow(timeoutSeconds);
9723 }
9724 /**
9725 * \brief Clear sticky fault: The remote sensor position has
9726 * overflowed. Because of the nature of remote sensors, it is possible
9727 * for the remote sensor position to overflow beyond what is supported
9728 * by the status signal frame. However, this is rare and cannot occur
9729 * over the course of an FRC match under normal use.
9730 *
9731 * This will wait up to 0.100 seconds (100ms) by default.
9732 *
9733 * \returns StatusCode of the set command
9734 */
9735 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow() final
9736 {
9737 return ClearStickyFault_RemoteSensorPosOverflow(0.100_s);
9738 }
9739
9740 /**
9741 * \brief Clear sticky fault: Supply Voltage has exceeded the maximum
9742 * voltage rating of device.
9743 *
9744 * \param timeoutSeconds Maximum time to wait up to in seconds.
9745 * \returns StatusCode of the set command
9746 */
9747 ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV(units::time::second_t timeoutSeconds) final
9748 {
9749 return GetConfigurator().ClearStickyFault_OverSupplyV(timeoutSeconds);
9750 }
9751 /**
9752 * \brief Clear sticky fault: Supply Voltage has exceeded the maximum
9753 * voltage rating of device.
9754 *
9755 * This will wait up to 0.100 seconds (100ms) by default.
9756 *
9757 * \returns StatusCode of the set command
9758 */
9759 ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV() final
9760 {
9761 return ClearStickyFault_OverSupplyV(0.100_s);
9762 }
9763
9764 /**
9765 * \brief Clear sticky fault: Supply Voltage is unstable. Ensure you
9766 * are using a battery and current limited power supply.
9767 *
9768 * \param timeoutSeconds Maximum time to wait up to in seconds.
9769 * \returns StatusCode of the set command
9770 */
9771 ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV(units::time::second_t timeoutSeconds) final
9772 {
9773 return GetConfigurator().ClearStickyFault_UnstableSupplyV(timeoutSeconds);
9774 }
9775 /**
9776 * \brief Clear sticky fault: Supply Voltage is unstable. Ensure you
9777 * are using a battery and current limited power supply.
9778 *
9779 * This will wait up to 0.100 seconds (100ms) by default.
9780 *
9781 * \returns StatusCode of the set command
9782 */
9783 ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV() final
9784 {
9785 return ClearStickyFault_UnstableSupplyV(0.100_s);
9786 }
9787
9788 /**
9789 * \brief Clear sticky fault: Reverse limit switch has been asserted.
9790 * Output is set to neutral.
9791 *
9792 * \param timeoutSeconds Maximum time to wait up to in seconds.
9793 * \returns StatusCode of the set command
9794 */
9795 ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit(units::time::second_t timeoutSeconds) final
9796 {
9797 return GetConfigurator().ClearStickyFault_ReverseHardLimit(timeoutSeconds);
9798 }
9799 /**
9800 * \brief Clear sticky fault: Reverse limit switch has been asserted.
9801 * Output is set to neutral.
9802 *
9803 * This will wait up to 0.100 seconds (100ms) by default.
9804 *
9805 * \returns StatusCode of the set command
9806 */
9807 ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit() final
9808 {
9809 return ClearStickyFault_ReverseHardLimit(0.100_s);
9810 }
9811
9812 /**
9813 * \brief Clear sticky fault: Forward limit switch has been asserted.
9814 * Output is set to neutral.
9815 *
9816 * \param timeoutSeconds Maximum time to wait up to in seconds.
9817 * \returns StatusCode of the set command
9818 */
9819 ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit(units::time::second_t timeoutSeconds) final
9820 {
9821 return GetConfigurator().ClearStickyFault_ForwardHardLimit(timeoutSeconds);
9822 }
9823 /**
9824 * \brief Clear sticky fault: Forward limit switch has been asserted.
9825 * Output is set to neutral.
9826 *
9827 * This will wait up to 0.100 seconds (100ms) by default.
9828 *
9829 * \returns StatusCode of the set command
9830 */
9831 ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit() final
9832 {
9833 return ClearStickyFault_ForwardHardLimit(0.100_s);
9834 }
9835
9836 /**
9837 * \brief Clear sticky fault: Reverse soft limit has been asserted.
9838 * Output is set to neutral.
9839 *
9840 * \param timeoutSeconds Maximum time to wait up to in seconds.
9841 * \returns StatusCode of the set command
9842 */
9843 ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit(units::time::second_t timeoutSeconds) final
9844 {
9845 return GetConfigurator().ClearStickyFault_ReverseSoftLimit(timeoutSeconds);
9846 }
9847 /**
9848 * \brief Clear sticky fault: Reverse soft limit has been asserted.
9849 * Output is set to neutral.
9850 *
9851 * This will wait up to 0.100 seconds (100ms) by default.
9852 *
9853 * \returns StatusCode of the set command
9854 */
9855 ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit() final
9856 {
9857 return ClearStickyFault_ReverseSoftLimit(0.100_s);
9858 }
9859
9860 /**
9861 * \brief Clear sticky fault: Forward soft limit has been asserted.
9862 * Output is set to neutral.
9863 *
9864 * \param timeoutSeconds Maximum time to wait up to in seconds.
9865 * \returns StatusCode of the set command
9866 */
9867 ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit(units::time::second_t timeoutSeconds) final
9868 {
9869 return GetConfigurator().ClearStickyFault_ForwardSoftLimit(timeoutSeconds);
9870 }
9871 /**
9872 * \brief Clear sticky fault: Forward soft limit has been asserted.
9873 * Output is set to neutral.
9874 *
9875 * This will wait up to 0.100 seconds (100ms) by default.
9876 *
9877 * \returns StatusCode of the set command
9878 */
9879 ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit() final
9880 {
9881 return ClearStickyFault_ForwardSoftLimit(0.100_s);
9882 }
9883
9884 /**
9885 * \brief Clear sticky fault: The remote soft limit device is not
9886 * present on CAN Bus.
9887 *
9888 * \param timeoutSeconds Maximum time to wait up to in seconds.
9889 * \returns StatusCode of the set command
9890 */
9891 ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote(units::time::second_t timeoutSeconds) final
9892 {
9893 return GetConfigurator().ClearStickyFault_MissingSoftLimitRemote(timeoutSeconds);
9894 }
9895 /**
9896 * \brief Clear sticky fault: The remote soft limit device is not
9897 * present on CAN Bus.
9898 *
9899 * This will wait up to 0.100 seconds (100ms) by default.
9900 *
9901 * \returns StatusCode of the set command
9902 */
9903 ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote() final
9904 {
9905 return ClearStickyFault_MissingSoftLimitRemote(0.100_s);
9906 }
9907
9908 /**
9909 * \brief Clear sticky fault: The remote limit switch device is not
9910 * present on CAN Bus.
9911 *
9912 * \param timeoutSeconds Maximum time to wait up to in seconds.
9913 * \returns StatusCode of the set command
9914 */
9915 ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote(units::time::second_t timeoutSeconds) final
9916 {
9917 return GetConfigurator().ClearStickyFault_MissingHardLimitRemote(timeoutSeconds);
9918 }
9919 /**
9920 * \brief Clear sticky fault: The remote limit switch device is not
9921 * present on CAN Bus.
9922 *
9923 * This will wait up to 0.100 seconds (100ms) by default.
9924 *
9925 * \returns StatusCode of the set command
9926 */
9927 ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote() final
9928 {
9929 return ClearStickyFault_MissingHardLimitRemote(0.100_s);
9930 }
9931
9932 /**
9933 * \brief Clear sticky fault: The remote sensor's data is no longer
9934 * trusted. This can happen if the remote sensor disappears from the
9935 * CAN bus or if the remote sensor indicates its data is no longer
9936 * valid, such as when a CANcoder's magnet strength falls into the
9937 * "red" range.
9938 *
9939 * \param timeoutSeconds Maximum time to wait up to in seconds.
9940 * \returns StatusCode of the set command
9941 */
9942 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid(units::time::second_t timeoutSeconds) final
9943 {
9944 return GetConfigurator().ClearStickyFault_RemoteSensorDataInvalid(timeoutSeconds);
9945 }
9946 /**
9947 * \brief Clear sticky fault: The remote sensor's data is no longer
9948 * trusted. This can happen if the remote sensor disappears from the
9949 * CAN bus or if the remote sensor indicates its data is no longer
9950 * valid, such as when a CANcoder's magnet strength falls into the
9951 * "red" range.
9952 *
9953 * This will wait up to 0.100 seconds (100ms) by default.
9954 *
9955 * \returns StatusCode of the set command
9956 */
9957 ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid() final
9958 {
9959 return ClearStickyFault_RemoteSensorDataInvalid(0.100_s);
9960 }
9961
9962 /**
9963 * \brief Clear sticky fault: The remote sensor used for fusion has
9964 * fallen out of sync to the local sensor. A re-synchronization has
9965 * occurred, which may cause a discontinuity. This typically happens
9966 * if there is significant slop in the mechanism, or if the
9967 * RotorToSensorRatio configuration parameter is incorrect.
9968 *
9969 * \param timeoutSeconds Maximum time to wait up to in seconds.
9970 * \returns StatusCode of the set command
9971 */
9972 ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync(units::time::second_t timeoutSeconds) final
9973 {
9974 return GetConfigurator().ClearStickyFault_FusedSensorOutOfSync(timeoutSeconds);
9975 }
9976 /**
9977 * \brief Clear sticky fault: The remote sensor used for fusion has
9978 * fallen out of sync to the local sensor. A re-synchronization has
9979 * occurred, which may cause a discontinuity. This typically happens
9980 * if there is significant slop in the mechanism, or if the
9981 * RotorToSensorRatio configuration parameter is incorrect.
9982 *
9983 * This will wait up to 0.100 seconds (100ms) by default.
9984 *
9985 * \returns StatusCode of the set command
9986 */
9987 ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync() final
9988 {
9989 return ClearStickyFault_FusedSensorOutOfSync(0.100_s);
9990 }
9991
9992 /**
9993 * \brief Clear sticky fault: Stator current limit occured.
9994 *
9995 * \param timeoutSeconds Maximum time to wait up to in seconds.
9996 * \returns StatusCode of the set command
9997 */
9998 ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit(units::time::second_t timeoutSeconds) final
9999 {
10000 return GetConfigurator().ClearStickyFault_StatorCurrLimit(timeoutSeconds);
10001 }
10002 /**
10003 * \brief Clear sticky fault: Stator current limit occured.
10004 *
10005 * This will wait up to 0.100 seconds (100ms) by default.
10006 *
10007 * \returns StatusCode of the set command
10008 */
10009 ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit() final
10010 {
10011 return ClearStickyFault_StatorCurrLimit(0.100_s);
10012 }
10013
10014 /**
10015 * \brief Clear sticky fault: Supply current limit occured.
10016 *
10017 * \param timeoutSeconds Maximum time to wait up to in seconds.
10018 * \returns StatusCode of the set command
10019 */
10020 ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit(units::time::second_t timeoutSeconds) final
10021 {
10022 return GetConfigurator().ClearStickyFault_SupplyCurrLimit(timeoutSeconds);
10023 }
10024 /**
10025 * \brief Clear sticky fault: Supply current limit occured.
10026 *
10027 * This will wait up to 0.100 seconds (100ms) by default.
10028 *
10029 * \returns StatusCode of the set command
10030 */
10031 ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit() final
10032 {
10033 return ClearStickyFault_SupplyCurrLimit(0.100_s);
10034 }
10035
10036 /**
10037 * \brief Clear sticky fault: Using Fused CANcoder feature while
10038 * unlicensed. Device has fallen back to remote CANcoder.
10039 *
10040 * \param timeoutSeconds Maximum time to wait up to in seconds.
10041 * \returns StatusCode of the set command
10042 */
10043 ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(units::time::second_t timeoutSeconds) final
10044 {
10045 return GetConfigurator().ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(timeoutSeconds);
10046 }
10047 /**
10048 * \brief Clear sticky fault: Using Fused CANcoder feature while
10049 * unlicensed. Device has fallen back to remote CANcoder.
10050 *
10051 * This will wait up to 0.100 seconds (100ms) by default.
10052 *
10053 * \returns StatusCode of the set command
10054 */
10055 ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed() final
10056 {
10057 return ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(0.100_s);
10058 }
10059
10060 /**
10061 * \brief Clear sticky fault: Static brake was momentarily disabled
10062 * due to excessive braking current while disabled.
10063 *
10064 * \param timeoutSeconds Maximum time to wait up to in seconds.
10065 * \returns StatusCode of the set command
10066 */
10067 ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled(units::time::second_t timeoutSeconds) final
10068 {
10069 return GetConfigurator().ClearStickyFault_StaticBrakeDisabled(timeoutSeconds);
10070 }
10071 /**
10072 * \brief Clear sticky fault: Static brake was momentarily disabled
10073 * due to excessive braking current while disabled.
10074 *
10075 * This will wait up to 0.100 seconds (100ms) by default.
10076 *
10077 * \returns StatusCode of the set command
10078 */
10079 ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled() final
10080 {
10081 return ClearStickyFault_StaticBrakeDisabled(0.100_s);
10082 }
10083
10084 /**
10085 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
10086 * caused a brief loss of position data triggering a recovery while
10087 * not in motion. If the event occurs often, inspect for excess axial
10088 * force or sources of ESD at the rotor.
10089 *
10090 * \param timeoutSeconds Maximum time to wait up to in seconds.
10091 * \returns StatusCode of the set command
10092 */
10093 ctre::phoenix::StatusCode ClearStickyFault_RotorFault1(units::time::second_t timeoutSeconds) final
10094 {
10095 return GetConfigurator().ClearStickyFault_RotorFault1(timeoutSeconds);
10096 }
10097 /**
10098 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
10099 * caused a brief loss of position data triggering a recovery while
10100 * not in motion. If the event occurs often, inspect for excess axial
10101 * force or sources of ESD at the rotor.
10102 *
10103 * This will wait up to 0.100 seconds (100ms) by default.
10104 *
10105 * \returns StatusCode of the set command
10106 */
10107 ctre::phoenix::StatusCode ClearStickyFault_RotorFault1() final
10108 {
10109 return ClearStickyFault_RotorFault1(0.100_s);
10110 }
10111
10112 /**
10113 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
10114 * caused a brief loss of position data triggering a recovery while in
10115 * motion. If the event occurs often, inspect for excess axial force
10116 * or sources of ESD at the rotor.
10117 *
10118 * \param timeoutSeconds Maximum time to wait up to in seconds.
10119 * \returns StatusCode of the set command
10120 */
10121 ctre::phoenix::StatusCode ClearStickyFault_RotorFault2(units::time::second_t timeoutSeconds) final
10122 {
10123 return GetConfigurator().ClearStickyFault_RotorFault2(timeoutSeconds);
10124 }
10125 /**
10126 * \brief Clear sticky fault: Trips if a major mechanical or ESD event
10127 * caused a brief loss of position data triggering a recovery while in
10128 * motion. If the event occurs often, inspect for excess axial force
10129 * or sources of ESD at the rotor.
10130 *
10131 * This will wait up to 0.100 seconds (100ms) by default.
10132 *
10133 * \returns StatusCode of the set command
10134 */
10135 ctre::phoenix::StatusCode ClearStickyFault_RotorFault2() final
10136 {
10137 return ClearStickyFault_RotorFault2(0.100_s);
10138 }
10139};
10140
10141#if defined(_WIN32) || defined(_WIN64)
10142#pragma warning(pop)
10143#endif
10144
10145}
10146}
10147
10148}
10149}
10150
Diff_DutyCycleOut_Open.hpp
Diff_DutyCycleOut_Position.hpp
Diff_DutyCycleOut_Velocity.hpp
Diff_MotionMagicDutyCycle_Open.hpp
Diff_MotionMagicDutyCycle_Position.hpp
Diff_MotionMagicDutyCycle_Velocity.hpp
Diff_MotionMagicExpoDutyCycle_Open.hpp
Diff_MotionMagicExpoDutyCycle_Position.hpp
Diff_MotionMagicExpoDutyCycle_Velocity.hpp
Diff_MotionMagicExpoTorqueCurrentFOC_Open.hpp
Diff_MotionMagicExpoTorqueCurrentFOC_Position.hpp
Diff_MotionMagicExpoTorqueCurrentFOC_Velocity.hpp
Diff_MotionMagicExpoVoltage_Open.hpp
Diff_MotionMagicExpoVoltage_Position.hpp
Diff_MotionMagicExpoVoltage_Velocity.hpp
Diff_MotionMagicTorqueCurrentFOC_Open.hpp
Diff_MotionMagicTorqueCurrentFOC_Position.hpp
Diff_MotionMagicTorqueCurrentFOC_Velocity.hpp
Diff_MotionMagicVelocityDutyCycle_Open.hpp
Diff_MotionMagicVelocityDutyCycle_Position.hpp
Diff_MotionMagicVelocityDutyCycle_Velocity.hpp
Diff_MotionMagicVelocityTorqueCurrentFOC_Open.hpp
Diff_MotionMagicVelocityTorqueCurrentFOC_Position.hpp
Diff_MotionMagicVelocityTorqueCurrentFOC_Velocity.hpp
Diff_MotionMagicVelocityVoltage_Open.hpp
Diff_MotionMagicVelocityVoltage_Position.hpp
Diff_MotionMagicVelocityVoltage_Velocity.hpp
Diff_MotionMagicVoltage_Open.hpp
Diff_MotionMagicVoltage_Position.hpp
Diff_MotionMagicVoltage_Velocity.hpp
Diff_PositionDutyCycle_Open.hpp
Diff_PositionDutyCycle_Position.hpp
Diff_PositionDutyCycle_Velocity.hpp
Diff_PositionTorqueCurrentFOC_Open.hpp
Diff_PositionTorqueCurrentFOC_Position.hpp
Diff_PositionTorqueCurrentFOC_Velocity.hpp
Diff_PositionVoltage_Open.hpp
Diff_PositionVoltage_Position.hpp
Diff_PositionVoltage_Velocity.hpp
Diff_TorqueCurrentFOC_Open.hpp
Diff_TorqueCurrentFOC_Position.hpp
Diff_TorqueCurrentFOC_Velocity.hpp
Diff_VelocityDutyCycle_Open.hpp
Diff_VelocityDutyCycle_Position.hpp
Diff_VelocityDutyCycle_Velocity.hpp
Diff_VelocityTorqueCurrentFOC_Open.hpp
Diff_VelocityTorqueCurrentFOC_Position.hpp
Diff_VelocityTorqueCurrentFOC_Velocity.hpp
Diff_VelocityVoltage_Open.hpp
Diff_VelocityVoltage_Position.hpp
Diff_VelocityVoltage_Velocity.hpp
Diff_VoltageOut_Open.hpp
Diff_VoltageOut_Position.hpp
Diff_VoltageOut_Velocity.hpp
ctre::phoenix6::CANBus
Class for getting information about an available CAN bus.
Definition CANBus.hpp:19
ctre::phoenix6::StatusSignal
Represents a status signal with data of type T, and operations available to retrieve information abou...
Definition StatusSignal.hpp:567
ctre::phoenix6::configs::AudioConfigs
Configs that affect audible components of the device.
Definition AudioConfigs.hpp:23
ctre::phoenix6::configs::AudioConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::AudioConfigs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::ClosedLoopGeneralConfigs
Configs that affect general behavior during closed-looping.
Definition ClosedLoopGeneralConfigs.hpp:24
ctre::phoenix6::configs::ClosedLoopGeneralConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::ClosedLoopRampsConfigs
Configs that affect the closed-loop control of this motor controller.
Definition ClosedLoopRampsConfigs.hpp:24
ctre::phoenix6::configs::ClosedLoopRampsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::CurrentLimitsConfigs
Configs that directly affect current limiting features.
Definition CurrentLimitsConfigs.hpp:25
ctre::phoenix6::configs::CurrentLimitsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::CustomParamsConfigs
Custom Params.
Definition CustomParamsConfigs.hpp:23
ctre::phoenix6::configs::CustomParamsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::DifferentialConstantsConfigs
Configs related to constants used for differential control of a mechanism.
Definition DifferentialConstantsConfigs.hpp:26
ctre::phoenix6::configs::DifferentialConstantsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::DifferentialSensorsConfigs
Configs related to sensors used for differential control of a mechanism.
Definition DifferentialSensorsConfigs.hpp:25
ctre::phoenix6::configs::DifferentialSensorsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::FeedbackConfigs
Configs that affect the feedback of this motor controller.
Definition FeedbackConfigs.hpp:31
ctre::phoenix6::configs::FeedbackConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::FeedbackConfigs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::HardwareLimitSwitchConfigs
Configs that change how the motor controller behaves under different limit switch states.
Definition HardwareLimitSwitchConfigs.hpp:30
ctre::phoenix6::configs::HardwareLimitSwitchConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::MotionMagicConfigs
Configs for Motion Magic®.
Definition MotionMagicConfigs.hpp:27
ctre::phoenix6::configs::MotionMagicConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::MotorOutputConfigs
Configs that directly affect motor output.
Definition MotorOutputConfigs.hpp:26
ctre::phoenix6::configs::MotorOutputConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::OpenLoopRampsConfigs
Configs that affect the open-loop control of this motor controller.
Definition OpenLoopRampsConfigs.hpp:24
ctre::phoenix6::configs::OpenLoopRampsConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::ParentConfiguration
Definition Configuration.hpp:17
ctre::phoenix6::configs::ParentConfigurator
The base class for all device configurators.
Definition Configurator.hpp:21
ctre::phoenix6::configs::Slot0Configs
Gains for the specified slot.
Definition Slot0Configs.hpp:26
ctre::phoenix6::configs::Slot0Configs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::Slot0Configs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::Slot1Configs
Gains for the specified slot.
Definition Slot1Configs.hpp:26
ctre::phoenix6::configs::Slot1Configs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::Slot1Configs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::Slot2Configs
Gains for the specified slot.
Definition Slot2Configs.hpp:26
ctre::phoenix6::configs::Slot2Configs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::Slot2Configs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::SlotConfigs
Gains for the specified slot.
Definition SlotConfigs.hpp:26
ctre::phoenix6::configs::SlotConfigs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::SlotConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::SoftwareLimitSwitchConfigs
Configs that affect how software-limit switches behave.
Definition SoftwareLimitSwitchConfigs.hpp:24
ctre::phoenix6::configs::SoftwareLimitSwitchConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::TalonFXConfiguration
Class description for the Talon FX integrated motor controller.
Definition CoreTalonFX.hpp:158
ctre::phoenix6::configs::TalonFXConfiguration::TorqueCurrent
TorqueCurrentConfigs TorqueCurrent
Configs that affect Torque Current control types.
Definition CoreTalonFX.hpp:243
ctre::phoenix6::configs::TalonFXConfiguration::WithTorqueCurrent
constexpr TalonFXConfiguration & WithTorqueCurrent(TorqueCurrentConfigs newTorqueCurrent)
Modifies this configuration's TorqueCurrent parameter and returns itself for method-chaining and easi...
Definition CoreTalonFX.hpp:597
ctre::phoenix6::configs::TalonFXConfiguration::MotorOutput
MotorOutputConfigs MotorOutput
Configs that directly affect motor output.
Definition CoreTalonFX.hpp:194
ctre::phoenix6::configs::TalonFXConfiguration::WithAudio
constexpr TalonFXConfiguration & WithAudio(AudioConfigs newAudio)
Modifies this configuration's Audio parameter and returns itself for method-chaining and easier to us...
Definition CoreTalonFX.hpp:787
ctre::phoenix6::configs::TalonFXConfiguration::WithOpenLoopRamps
constexpr TalonFXConfiguration & WithOpenLoopRamps(OpenLoopRampsConfigs newOpenLoopRamps)
Modifies this configuration's OpenLoopRamps parameter and returns itself for method-chaining and easi...
Definition CoreTalonFX.hpp:702
ctre::phoenix6::configs::TalonFXConfiguration::FutureProofConfigs
bool FutureProofConfigs
True if we should factory default newer unsupported configs, false to leave newer unsupported configs...
Definition CoreTalonFX.hpp:175
ctre::phoenix6::configs::TalonFXConfiguration::WithSlot1
constexpr TalonFXConfiguration & WithSlot1(Slot1Configs newSlot1)
Modifies this configuration's Slot1 parameter and returns itself for method-chaining and easier to us...
Definition CoreTalonFX.hpp:954
ctre::phoenix6::configs::TalonFXConfiguration::WithHardwareLimitSwitch
constexpr TalonFXConfiguration & WithHardwareLimitSwitch(HardwareLimitSwitchConfigs newHardwareLimitSwitch)
Modifies this configuration's HardwareLimitSwitch parameter and returns itself for method-chaining an...
Definition CoreTalonFX.hpp:763
ctre::phoenix6::configs::TalonFXConfiguration::WithFeedback
constexpr TalonFXConfiguration & WithFeedback(FeedbackConfigs newFeedback)
Modifies this configuration's Feedback parameter and returns itself for method-chaining and easier to...
Definition CoreTalonFX.hpp:627
ctre::phoenix6::configs::TalonFXConfiguration::ToString
std::string ToString() const override
Get the string representation of this configuration.
ctre::phoenix6::configs::TalonFXConfiguration::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
Take a string and deserialize it to this configuration.
ctre::phoenix6::configs::TalonFXConfiguration::WithClosedLoopRamps
constexpr TalonFXConfiguration & WithClosedLoopRamps(ClosedLoopRampsConfigs newClosedLoopRamps)
Modifies this configuration's ClosedLoopRamps parameter and returns itself for method-chaining and ea...
Definition CoreTalonFX.hpp:727
ctre::phoenix6::configs::TalonFXConfiguration::WithMotionMagic
constexpr TalonFXConfiguration & WithMotionMagic(MotionMagicConfigs newMotionMagic)
Modifies this configuration's MotionMagic parameter and returns itself for method-chaining and easier...
Definition CoreTalonFX.hpp:840
ctre::phoenix6::configs::TalonFXConfiguration::WithDifferentialConstants
constexpr TalonFXConfiguration & WithDifferentialConstants(DifferentialConstantsConfigs newDifferentialConstants)
Modifies this configuration's DifferentialConstants parameter and returns itself for method-chaining ...
Definition CoreTalonFX.hpp:678
ctre::phoenix6::configs::TalonFXConfiguration::WithClosedLoopGeneral
constexpr TalonFXConfiguration & WithClosedLoopGeneral(ClosedLoopGeneralConfigs newClosedLoopGeneral)
Modifies this configuration's ClosedLoopGeneral parameter and returns itself for method-chaining and ...
Definition CoreTalonFX.hpp:888
ctre::phoenix6::configs::TalonFXConfiguration::WithCustomParams
constexpr TalonFXConfiguration & WithCustomParams(CustomParamsConfigs newCustomParams)
Modifies this configuration's CustomParams parameter and returns itself for method-chaining and easie...
Definition CoreTalonFX.hpp:863
ctre::phoenix6::configs::TalonFXConfiguration::WithSlot2
constexpr TalonFXConfiguration & WithSlot2(Slot2Configs newSlot2)
Modifies this configuration's Slot2 parameter and returns itself for method-chaining and easier to us...
Definition CoreTalonFX.hpp:987
ctre::phoenix6::configs::TalonFXConfiguration::DifferentialConstants
DifferentialConstantsConfigs DifferentialConstants
Configs related to constants used for differential control of a mechanism.
Definition CoreTalonFX.hpp:294
ctre::phoenix6::configs::TalonFXConfiguration::WithDifferentialSensors
constexpr TalonFXConfiguration & WithDifferentialSensors(DifferentialSensorsConfigs newDifferentialSensors)
Modifies this configuration's DifferentialSensors parameter and returns itself for method-chaining an...
Definition CoreTalonFX.hpp:653
ctre::phoenix6::configs::TalonFXConfiguration::Voltage
VoltageConfigs Voltage
Configs that affect Voltage control types.
Definition CoreTalonFX.hpp:227
ctre::phoenix6::configs::TalonFXConfiguration::HardwareLimitSwitch
HardwareLimitSwitchConfigs HardwareLimitSwitch
Configs that change how the motor controller behaves under different limit switch states.
Definition CoreTalonFX.hpp:350
ctre::phoenix6::configs::TalonFXConfiguration::WithCurrentLimits
constexpr TalonFXConfiguration & WithCurrentLimits(CurrentLimitsConfigs newCurrentLimits)
Modifies this configuration's CurrentLimits parameter and returns itself for method-chaining and easi...
Definition CoreTalonFX.hpp:546
ctre::phoenix6::configs::TalonFXConfiguration::ClosedLoopRamps
ClosedLoopRampsConfigs ClosedLoopRamps
Configs that affect the closed-loop control of this motor controller.
Definition CoreTalonFX.hpp:324
ctre::phoenix6::configs::TalonFXConfiguration::Slot2
Slot2Configs Slot2
Gains for the specified slot.
Definition CoreTalonFX.hpp:494
ctre::phoenix6::configs::TalonFXConfiguration::OpenLoopRamps
OpenLoopRampsConfigs OpenLoopRamps
Configs that affect the open-loop control of this motor controller.
Definition CoreTalonFX.hpp:309
ctre::phoenix6::configs::TalonFXConfiguration::SoftwareLimitSwitch
SoftwareLimitSwitchConfigs SoftwareLimitSwitch
Configs that affect how software-limit switches behave.
Definition CoreTalonFX.hpp:380
ctre::phoenix6::configs::TalonFXConfiguration::MotionMagic
MotionMagicConfigs MotionMagic
Configs for Motion Magic®.
Definition CoreTalonFX.hpp:397
ctre::phoenix6::configs::TalonFXConfiguration::Feedback
FeedbackConfigs Feedback
Configs that affect the feedback of this motor controller.
Definition CoreTalonFX.hpp:263
ctre::phoenix6::configs::TalonFXConfiguration::Slot0
Slot0Configs Slot0
Gains for the specified slot.
Definition CoreTalonFX.hpp:448
ctre::phoenix6::configs::TalonFXConfiguration::WithSlot0
constexpr TalonFXConfiguration & WithSlot0(Slot0Configs newSlot0)
Modifies this configuration's Slot0 parameter and returns itself for method-chaining and easier to us...
Definition CoreTalonFX.hpp:921
ctre::phoenix6::configs::TalonFXConfiguration::Audio
AudioConfigs Audio
Configs that affect audible components of the device.
Definition CoreTalonFX.hpp:364
ctre::phoenix6::configs::TalonFXConfiguration::DifferentialSensors
DifferentialSensorsConfigs DifferentialSensors
Configs related to sensors used for differential control of a mechanism.
Definition CoreTalonFX.hpp:279
ctre::phoenix6::configs::TalonFXConfiguration::CurrentLimits
CurrentLimitsConfigs CurrentLimits
Configs that directly affect current limiting features.
Definition CoreTalonFX.hpp:212
ctre::phoenix6::configs::TalonFXConfiguration::WithMotorOutput
constexpr TalonFXConfiguration & WithMotorOutput(MotorOutputConfigs newMotorOutput)
Modifies this configuration's MotorOutput parameter and returns itself for method-chaining and easier...
Definition CoreTalonFX.hpp:518
ctre::phoenix6::configs::TalonFXConfiguration::CustomParams
CustomParamsConfigs CustomParams
Custom Params.
Definition CoreTalonFX.hpp:410
ctre::phoenix6::configs::TalonFXConfiguration::Serialize
std::string Serialize() const final
Get the serialized form of this configuration.
ctre::phoenix6::configs::TalonFXConfiguration::ClosedLoopGeneral
ClosedLoopGeneralConfigs ClosedLoopGeneral
Configs that affect general behavior during closed-looping.
Definition CoreTalonFX.hpp:425
ctre::phoenix6::configs::TalonFXConfiguration::WithVoltage
constexpr TalonFXConfiguration & WithVoltage(VoltageConfigs newVoltage)
Modifies this configuration's Voltage parameter and returns itself for method-chaining and easier to ...
Definition CoreTalonFX.hpp:571
ctre::phoenix6::configs::TalonFXConfiguration::Slot1
Slot1Configs Slot1
Gains for the specified slot.
Definition CoreTalonFX.hpp:471
ctre::phoenix6::configs::TalonFXConfiguration::WithSoftwareLimitSwitch
constexpr TalonFXConfiguration & WithSoftwareLimitSwitch(SoftwareLimitSwitchConfigs newSoftwareLimitSwitch)
Modifies this configuration's SoftwareLimitSwitch parameter and returns itself for method-chaining an...
Definition CoreTalonFX.hpp:813
ctre::phoenix6::configs::TalonFXConfigurator
Class description for the Talon FX integrated motor controller.
Definition CoreTalonFX.hpp:1014
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorDataInvalid
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid()
Clear sticky fault: The remote sensor's data is no longer trusted.
Definition CoreTalonFX.hpp:2908
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(AudioConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1955
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorPosOverflow
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote sensor position has overflowed.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ForwardSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit()
Clear sticky fault: Forward soft limit has been asserted.
Definition CoreTalonFX.hpp:2806
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingHardLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote limit switch device is not present on CAN Bus.
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot1Configs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2154
ctre::phoenix6::configs::TalonFXConfigurator::SetPosition
ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue)
Sets the mechanism position of the device in mechanism rotations.
Definition CoreTalonFX.hpp:2240
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorDataInvalid
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote sensor's data is no longer trusted.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFaults
ctre::phoenix::StatusCode ClearStickyFaults()
Clear the sticky faults in the device.
Definition CoreTalonFX.hpp:2277
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const DifferentialConstantsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1250
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1862
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const AudioConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1352
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(FeedbackConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1769
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot0Configs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1511
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot0Configs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2110
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2092
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1986
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const TalonFXConfiguration &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1033
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const MotionMagicConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1410
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ProcTemp
ctre::phoenix::StatusCode ClearStickyFault_ProcTemp(units::time::second_t timeoutSeconds)
Clear sticky fault: Processor temperature exceeded limit.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const DifferentialSensorsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1207
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot2Configs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2185
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_BridgeBrownout
ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout(units::time::second_t timeoutSeconds)
Clear sticky fault: Bridge was disabled most likely due to supply voltage dropping too low.
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1906
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_Undervoltage
ctre::phoenix::StatusCode ClearStickyFault_Undervoltage()
Clear sticky fault: Device supply voltage dropped to near brownout levels.
Definition CoreTalonFX.hpp:2406
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(MotionMagicConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2017
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot2Configs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1569
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_OverSupplyV
ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV(units::time::second_t timeoutSeconds)
Clear sticky fault: Supply Voltage has exceeded the maximum voltage rating of device.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_StaticBrakeDisabled
ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled(units::time::second_t timeoutSeconds)
Clear sticky fault: Static brake was momentarily disabled due to excessive braking current while disa...
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const DifferentialConstantsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1236
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(VoltageConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1720
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ProcTemp
ctre::phoenix::StatusCode ClearStickyFault_ProcTemp()
Clear sticky fault: Processor temperature exceeded limit.
Definition CoreTalonFX.hpp:2343
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(SlotConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2203
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot1Configs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2141
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(CustomParamsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2048
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_DeviceTemp
ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp()
Clear sticky fault: Device temperature exceeded limit.
Definition CoreTalonFX.hpp:2374
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ForwardSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Forward soft limit has been asserted.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const CustomParamsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1453
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(ClosedLoopGeneralConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2079
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot2Configs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2172
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_StaticBrakeDisabled
ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled()
Clear sticky fault: Static brake was momentarily disabled due to excessive braking current while disa...
Definition CoreTalonFX.hpp:3078
ctre::phoenix6::configs::TalonFXConfigurator::SetPosition
ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue, units::time::second_t timeoutSeconds)
Sets the mechanism position of the device in mechanism rotations.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_Hardware
ctre::phoenix::StatusCode ClearStickyFault_Hardware()
Clear sticky fault: Hardware fault occurred.
Definition CoreTalonFX.hpp:2312
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const SlotConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1598
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1265
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RotorFault1
ctre::phoenix::StatusCode ClearStickyFault_RotorFault1(units::time::second_t timeoutSeconds)
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot1Configs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1540
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ReverseSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Reverse soft limit has been asserted.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ReverseSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit()
Clear sticky fault: Reverse soft limit has been asserted.
Definition CoreTalonFX.hpp:2773
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(VoltageConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1707
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(FeedbackConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1782
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1294
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const TalonFXConfiguration &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1047
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const ClosedLoopRampsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1308
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UnlicensedFeatureInUse
ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse()
Clear sticky fault: An unlicensed feature is in use, device may not behave as expected.
Definition CoreTalonFX.hpp:2472
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1395
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot0Configs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1497
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const CustomParamsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1439
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RotorFault1
ctre::phoenix::StatusCode ClearStickyFault_RotorFault1()
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:3113
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1163
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_FusedSensorOutOfSync
ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote sensor used for fusion has fallen out of sync to the local sensor.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorPosOverflow
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow()
Clear sticky fault: The remote sensor position has overflowed.
Definition CoreTalonFX.hpp:2605
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_Hardware
ctre::phoenix::StatusCode ClearStickyFault_Hardware(units::time::second_t timeoutSeconds)
Clear sticky fault: Hardware fault occurred.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1468
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_Undervoltage
ctre::phoenix::StatusCode ClearStickyFault_Undervoltage(units::time::second_t timeoutSeconds)
Clear sticky fault: Device supply voltage dropped to near brownout levels.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const ClosedLoopGeneralConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1482
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(CustomParamsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2061
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(SoftwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1999
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const MotorOutputConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1062
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot2Configs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1555
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const MotionMagicConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1424
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFaults
ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds)
Clear the sticky faults in the device.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UnstableSupplyV
ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV(units::time::second_t timeoutSeconds)
Clear sticky fault: Supply Voltage is unstable.
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(AudioConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1968
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const VoltageConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1134
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(MotorOutputConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1658
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1676
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_BootDuringEnable
ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable()
Clear sticky fault: Device boot while detecting the enable signal.
Definition CoreTalonFX.hpp:2439
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_OverSupplyV
ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV()
Clear sticky fault: Supply Voltage has exceeded the maximum voltage rating of device.
Definition CoreTalonFX.hpp:2641
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(TalonFXConfiguration &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1627
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(DifferentialSensorsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1800
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UsingFusedCANcoderWhileUnlicensed
ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed()
Clear sticky fault: Using Fused CANcoder feature while unlicensed.
Definition CoreTalonFX.hpp:3045
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1738
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_BridgeBrownout
ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout()
Clear sticky fault: Bridge was disabled most likely due to supply voltage dropping too low.
Definition CoreTalonFX.hpp:2505
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const SlotConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1584
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorReset
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote sensor has reset.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UnlicensedFeatureInUse
ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse(units::time::second_t timeoutSeconds)
Clear sticky fault: An unlicensed feature is in use, device may not behave as expected.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_SupplyCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit()
Clear sticky fault: Supply current limit occured.
Definition CoreTalonFX.hpp:3013
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UnstableSupplyV
ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV()
Clear sticky fault: Supply Voltage is unstable.
Definition CoreTalonFX.hpp:2674
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(OpenLoopRampsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1875
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const Slot1Configs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1526
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const SoftwareLimitSwitchConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1381
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(DifferentialSensorsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1813
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingDifferentialFX
ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote Talon used for differential control is not present on CAN Bus.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ForwardHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit()
Clear sticky fault: Forward limit switch has been asserted.
Definition CoreTalonFX.hpp:2740
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RotorFault2
ctre::phoenix::StatusCode ClearStickyFault_RotorFault2()
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:3150
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_StatorCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Stator current limit occured.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingHardLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote()
Clear sticky fault: The remote limit switch device is not present on CAN Bus.
Definition CoreTalonFX.hpp:2872
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_StatorCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit()
Clear sticky fault: Stator current limit occured.
Definition CoreTalonFX.hpp:2982
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1323
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_FusedSensorOutOfSync
ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync()
Clear sticky fault: The remote sensor used for fusion has fallen out of sync to the local sensor.
Definition CoreTalonFX.hpp:2947
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_DeviceTemp
ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp(units::time::second_t timeoutSeconds)
Clear sticky fault: Device temperature exceeded limit.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1105
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingSoftLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote()
Clear sticky fault: The remote soft limit device is not present on CAN Bus.
Definition CoreTalonFX.hpp:2839
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ReverseHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Reverse limit switch has been asserted.
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_UsingFusedCANcoderWhileUnlicensed
ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(units::time::second_t timeoutSeconds)
Clear sticky fault: Using Fused CANcoder feature while unlicensed.
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(DifferentialConstantsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1844
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_BootDuringEnable
ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable(units::time::second_t timeoutSeconds)
Clear sticky fault: Device boot while detecting the enable signal.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const HardwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1337
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const VoltageConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1120
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const FeedbackConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1178
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RemoteSensorReset
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset()
Clear sticky fault: The remote sensor has reset.
Definition CoreTalonFX.hpp:2537
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(DifferentialConstantsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1831
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingDifferentialFX
ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX()
Clear sticky fault: The remote Talon used for differential control is not present on CAN Bus.
Definition CoreTalonFX.hpp:2569
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(Slot0Configs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2123
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(TalonFXConfiguration &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1613
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const TorqueCurrentConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1149
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const DifferentialSensorsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1221
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_MissingSoftLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote(units::time::second_t timeoutSeconds)
Clear sticky fault: The remote soft limit device is not present on CAN Bus.
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1937
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const MotorOutputConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1076
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ReverseHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit()
Clear sticky fault: Reverse limit switch has been asserted.
Definition CoreTalonFX.hpp:2707
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(SlotConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2216
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(ClosedLoopRampsConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1893
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(MotorOutputConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1645
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const OpenLoopRampsConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1279
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(MotionMagicConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:2030
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const FeedbackConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1192
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(CurrentLimitsConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1689
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const AudioConfigs &configs, units::time::second_t timeoutSeconds)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1366
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_SupplyCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Supply current limit occured.
ctre::phoenix6::configs::TalonFXConfigurator::Apply
ctre::phoenix::StatusCode Apply(const CurrentLimitsConfigs &configs)
Applies the contents of the specified config to the device.
Definition CoreTalonFX.hpp:1091
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(TorqueCurrentConfigs &configs, units::time::second_t timeoutSeconds) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1751
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_RotorFault2
ctre::phoenix::StatusCode ClearStickyFault_RotorFault2(units::time::second_t timeoutSeconds)
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
ctre::phoenix6::configs::TalonFXConfigurator::Refresh
ctre::phoenix::StatusCode Refresh(HardwareLimitSwitchConfigs &configs) const
Refreshes the values of the specified config group.
Definition CoreTalonFX.hpp:1924
ctre::phoenix6::configs::TalonFXConfigurator::ClearStickyFault_ForwardHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit(units::time::second_t timeoutSeconds)
Clear sticky fault: Forward limit switch has been asserted.
ctre::phoenix6::configs::TorqueCurrentConfigs
Configs that affect Torque Current control types.
Definition TorqueCurrentConfigs.hpp:25
ctre::phoenix6::configs::TorqueCurrentConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::configs::VoltageConfigs
Configs that affect Voltage control types.
Definition VoltageConfigs.hpp:25
ctre::phoenix6::configs::VoltageConfigs::Serialize
std::string Serialize() const final
ctre::phoenix6::configs::VoltageConfigs::Deserialize
ctre::phoenix::StatusCode Deserialize(std::string const &to_deserialize) final
ctre::phoenix6::hardware::DeviceIdentifier
The unique identifier for a device.
Definition DeviceIdentifier.hpp:19
ctre::phoenix6::hardware::ParentDevice
Parent class for all devices.
Definition ParentDevice.hpp:23
ctre::phoenix6::hardware::core::CoreTalonFX
Class description for the Talon FX integrated motor controller.
Definition CoreTalonFX.hpp:3186
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UsingFusedCANcoderWhileUnlicensed
ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed(units::time::second_t timeoutSeconds) final
Clear sticky fault: Using Fused CANcoder feature while unlicensed.
Definition CoreTalonFX.hpp:10043
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_Undervoltage
ctre::phoenix::StatusCode ClearStickyFault_Undervoltage(units::time::second_t timeoutSeconds) final
Clear sticky fault: Device supply voltage dropped to near brownout levels.
Definition CoreTalonFX.hpp:9575
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UnlicensedFeatureInUse
ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse(units::time::second_t timeoutSeconds) final
Clear sticky fault: An unlicensed feature is in use, device may not behave as expected.
Definition CoreTalonFX.hpp:9623
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_StatorCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Stator current limit occured.
Definition CoreTalonFX.hpp:9998
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingDifferentialFX
ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX() final
Clear sticky fault: The remote Talon used for differential control is not present on CAN Bus.
Definition CoreTalonFX.hpp:9705
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_Hardware
ctre::phoenix::StatusCode ClearStickyFault_Hardware(units::time::second_t timeoutSeconds) final
Clear sticky fault: Hardware fault occurred.
Definition CoreTalonFX.hpp:9508
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingSoftLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote soft limit device is not present on CAN Bus.
Definition CoreTalonFX.hpp:9891
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_SupplyCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit() final
Clear sticky fault: Supply current limit occured.
Definition CoreTalonFX.hpp:10031
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RotorFault1
ctre::phoenix::StatusCode ClearStickyFault_RotorFault1() final
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:10107
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorPosOverflow
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote sensor position has overflowed.
Definition CoreTalonFX.hpp:9720
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_StaticBrakeDisabled
ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled() final
Clear sticky fault: Static brake was momentarily disabled due to excessive braking current while disa...
Definition CoreTalonFX.hpp:10079
ctre::phoenix6::hardware::core::CoreTalonFX::GetConfigurator
configs::TalonFXConfigurator const & GetConfigurator() const
Gets the configurator for this TalonFX.
Definition CoreTalonFX.hpp:3254
ctre::phoenix6::hardware::core::CoreTalonFX::SetPosition
ctre::phoenix::StatusCode SetPosition(units::angle::turn_t newValue) final
Sets the mechanism position of the device in mechanism rotations.
Definition CoreTalonFX.hpp:9467
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UnstableSupplyV
ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV() final
Clear sticky fault: Supply Voltage is unstable.
Definition CoreTalonFX.hpp:9783
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_FusedSensorOutOfSync
ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote sensor used for fusion has fallen out of sync to the local sensor.
Definition CoreTalonFX.hpp:9972
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ReverseSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Reverse soft limit has been asserted.
Definition CoreTalonFX.hpp:9843
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RotorFault1
ctre::phoenix::StatusCode ClearStickyFault_RotorFault1(units::time::second_t timeoutSeconds) final
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:10093
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_BridgeBrownout
ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout(units::time::second_t timeoutSeconds) final
Clear sticky fault: Bridge was disabled most likely due to supply voltage dropping too low.
Definition CoreTalonFX.hpp:9647
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorPosOverflow
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorPosOverflow() final
Clear sticky fault: The remote sensor position has overflowed.
Definition CoreTalonFX.hpp:9735
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingSoftLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingSoftLimitRemote() final
Clear sticky fault: The remote soft limit device is not present on CAN Bus.
Definition CoreTalonFX.hpp:9903
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RotorFault2
ctre::phoenix::StatusCode ClearStickyFault_RotorFault2() final
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:10135
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingHardLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote limit switch device is not present on CAN Bus.
Definition CoreTalonFX.hpp:9915
ctre::phoenix6::hardware::core::CoreTalonFX::None
static CoreTalonFX None()
Constructs a stubbed-out CoreTalonFX, where all status signals, controls, configs,...
Definition CoreTalonFX.hpp:3230
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ProcTemp
ctre::phoenix::StatusCode ClearStickyFault_ProcTemp(units::time::second_t timeoutSeconds) final
Clear sticky fault: Processor temperature exceeded limit.
Definition CoreTalonFX.hpp:9530
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_OverSupplyV
ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV() final
Clear sticky fault: Supply Voltage has exceeded the maximum voltage rating of device.
Definition CoreTalonFX.hpp:9759
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_Undervoltage
ctre::phoenix::StatusCode ClearStickyFault_Undervoltage() final
Clear sticky fault: Device supply voltage dropped to near brownout levels.
Definition CoreTalonFX.hpp:9587
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ForwardHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit() final
Clear sticky fault: Forward limit switch has been asserted.
Definition CoreTalonFX.hpp:9831
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingDifferentialFX
ctre::phoenix::StatusCode ClearStickyFault_MissingDifferentialFX(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote Talon used for differential control is not present on CAN Bus.
Definition CoreTalonFX.hpp:9693
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_OverSupplyV
ctre::phoenix::StatusCode ClearStickyFault_OverSupplyV(units::time::second_t timeoutSeconds) final
Clear sticky fault: Supply Voltage has exceeded the maximum voltage rating of device.
Definition CoreTalonFX.hpp:9747
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_DeviceTemp
ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp(units::time::second_t timeoutSeconds) final
Clear sticky fault: Device temperature exceeded limit.
Definition CoreTalonFX.hpp:9552
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_DeviceTemp
ctre::phoenix::StatusCode ClearStickyFault_DeviceTemp() final
Clear sticky fault: Device temperature exceeded limit.
Definition CoreTalonFX.hpp:9563
ctre::phoenix6::hardware::core::CoreTalonFX::CoreTalonFX
CoreTalonFX(int deviceId, std::string canbus)
Constructs a new Talon FX motor controller object.
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorDataInvalid
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote sensor's data is no longer trusted.
Definition CoreTalonFX.hpp:9942
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_FusedSensorOutOfSync
ctre::phoenix::StatusCode ClearStickyFault_FusedSensorOutOfSync() final
Clear sticky fault: The remote sensor used for fusion has fallen out of sync to the local sensor.
Definition CoreTalonFX.hpp:9987
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RotorFault2
ctre::phoenix::StatusCode ClearStickyFault_RotorFault2(units::time::second_t timeoutSeconds) final
Clear sticky fault: Trips if a major mechanical or ESD event caused a brief loss of position data tri...
Definition CoreTalonFX.hpp:10121
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ReverseSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseSoftLimit() final
Clear sticky fault: Reverse soft limit has been asserted.
Definition CoreTalonFX.hpp:9855
ctre::phoenix6::hardware::core::CoreTalonFX::GetConfigurator
configs::TalonFXConfigurator & GetConfigurator()
Gets the configurator for this TalonFX.
Definition CoreTalonFX.hpp:3242
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ReverseHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit() final
Clear sticky fault: Reverse limit switch has been asserted.
Definition CoreTalonFX.hpp:9807
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ForwardSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Forward soft limit has been asserted.
Definition CoreTalonFX.hpp:9867
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorReset
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset(units::time::second_t timeoutSeconds) final
Clear sticky fault: The remote sensor has reset.
Definition CoreTalonFX.hpp:9670
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_MissingHardLimitRemote
ctre::phoenix::StatusCode ClearStickyFault_MissingHardLimitRemote() final
Clear sticky fault: The remote limit switch device is not present on CAN Bus.
Definition CoreTalonFX.hpp:9927
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UnstableSupplyV
ctre::phoenix::StatusCode ClearStickyFault_UnstableSupplyV(units::time::second_t timeoutSeconds) final
Clear sticky fault: Supply Voltage is unstable.
Definition CoreTalonFX.hpp:9771
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_Hardware
ctre::phoenix::StatusCode ClearStickyFault_Hardware() final
Clear sticky fault: Hardware fault occurred.
Definition CoreTalonFX.hpp:9519
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_BootDuringEnable
ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable() final
Clear sticky fault: Device boot while detecting the enable signal.
Definition CoreTalonFX.hpp:9611
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UnlicensedFeatureInUse
ctre::phoenix::StatusCode ClearStickyFault_UnlicensedFeatureInUse() final
Clear sticky fault: An unlicensed feature is in use, device may not behave as expected.
Definition CoreTalonFX.hpp:9635
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ForwardSoftLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardSoftLimit() final
Clear sticky fault: Forward soft limit has been asserted.
Definition CoreTalonFX.hpp:9879
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ForwardHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ForwardHardLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Forward limit switch has been asserted.
Definition CoreTalonFX.hpp:9819
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_StaticBrakeDisabled
ctre::phoenix::StatusCode ClearStickyFault_StaticBrakeDisabled(units::time::second_t timeoutSeconds) final
Clear sticky fault: Static brake was momentarily disabled due to excessive braking current while disa...
Definition CoreTalonFX.hpp:10067
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_SupplyCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_SupplyCurrLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Supply current limit occured.
Definition CoreTalonFX.hpp:10020
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_UsingFusedCANcoderWhileUnlicensed
ctre::phoenix::StatusCode ClearStickyFault_UsingFusedCANcoderWhileUnlicensed() final
Clear sticky fault: Using Fused CANcoder feature while unlicensed.
Definition CoreTalonFX.hpp:10055
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_BootDuringEnable
ctre::phoenix::StatusCode ClearStickyFault_BootDuringEnable(units::time::second_t timeoutSeconds) final
Clear sticky fault: Device boot while detecting the enable signal.
Definition CoreTalonFX.hpp:9599
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_BridgeBrownout
ctre::phoenix::StatusCode ClearStickyFault_BridgeBrownout() final
Clear sticky fault: Bridge was disabled most likely due to supply voltage dropping too low.
Definition CoreTalonFX.hpp:9659
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorReset
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorReset() final
Clear sticky fault: The remote sensor has reset.
Definition CoreTalonFX.hpp:9681
ctre::phoenix6::hardware::core::CoreTalonFX::GetVersionMajor
StatusSignal< int > & GetVersionMajor(bool refresh=true) final
App Major Version number.
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_StatorCurrLimit
ctre::phoenix::StatusCode ClearStickyFault_StatorCurrLimit() final
Clear sticky fault: Stator current limit occured.
Definition CoreTalonFX.hpp:10009
ctre::phoenix6::hardware::core::CoreTalonFX::CoreTalonFX
CoreTalonFX(int deviceId, CANBus canbus={})
Constructs a new Talon FX motor controller object.
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ProcTemp
ctre::phoenix::StatusCode ClearStickyFault_ProcTemp() final
Clear sticky fault: Processor temperature exceeded limit.
Definition CoreTalonFX.hpp:9541
ctre::phoenix6::hardware::core::CoreTalonFX::GetSimState
sim::TalonFXSimState & GetSimState()
Get the simulation state for this device.
Definition CoreTalonFX.hpp:3272
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFaults
ctre::phoenix::StatusCode ClearStickyFaults() final
Clear the sticky faults in the device.
Definition CoreTalonFX.hpp:9497
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_RemoteSensorDataInvalid
ctre::phoenix::StatusCode ClearStickyFault_RemoteSensorDataInvalid() final
Clear sticky fault: The remote sensor's data is no longer trusted.
Definition CoreTalonFX.hpp:9957
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFault_ReverseHardLimit
ctre::phoenix::StatusCode ClearStickyFault_ReverseHardLimit(units::time::second_t timeoutSeconds) final
Clear sticky fault: Reverse limit switch has been asserted.
Definition CoreTalonFX.hpp:9795
ctre::phoenix6::hardware::core::CoreTalonFX::ClearStickyFaults
ctre::phoenix::StatusCode ClearStickyFaults(units::time::second_t timeoutSeconds) final
Clear the sticky faults in the device.
Definition CoreTalonFX.hpp:9482
ctre::phoenix6::hardware::traits::CommonTalonWithFOC
Contains everything common between Talon motor controllers that support FOC (requires Phoenix Pro).
Definition CommonTalonWithFOC.hpp:28
ctre::phoenix6::sim::TalonFXSimState
Class to control the state of a simulated hardware::TalonFX.
Definition TalonFXSimState.hpp:40
ctre::phoenix::StatusCode
Status codes reported by APIs, including OK, warnings, and errors.
Definition StatusCodes.h:28
motor_constants.h
ctre
Definition motor_constants.h:14