CTRE Phoenix 6 C++ 26.0.0-beta-1
Loading...
Searching...
No Matches
HasTalonControls.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/controls/ControlRequest.hpp"
10#include "ctre/phoenix6/signals/SpnEnums.hpp"
11#include "ctre/phoenix6/StatusSignal.hpp"
12#include "ctre/phoenix6/hardware/traits/CommonDevice.hpp"
13#include "ctre/phoenix6/controls/DutyCycleOut.hpp"
14#include "ctre/phoenix6/controls/VoltageOut.hpp"
15#include "ctre/phoenix6/controls/PositionDutyCycle.hpp"
16#include "ctre/phoenix6/controls/PositionVoltage.hpp"
17#include "ctre/phoenix6/controls/VelocityDutyCycle.hpp"
18#include "ctre/phoenix6/controls/VelocityVoltage.hpp"
19#include "ctre/phoenix6/controls/MotionMagicDutyCycle.hpp"
20#include "ctre/phoenix6/controls/MotionMagicVoltage.hpp"
21#include "ctre/phoenix6/controls/MotionMagicVelocityDutyCycle.hpp"
22#include "ctre/phoenix6/controls/MotionMagicVelocityVoltage.hpp"
23#include "ctre/phoenix6/controls/MotionMagicExpoDutyCycle.hpp"
24#include "ctre/phoenix6/controls/MotionMagicExpoVoltage.hpp"
25#include "ctre/phoenix6/controls/DynamicMotionMagicDutyCycle.hpp"
26#include "ctre/phoenix6/controls/DynamicMotionMagicVoltage.hpp"
27#include "ctre/phoenix6/controls/DynamicMotionMagicExpoDutyCycle.hpp"
28#include "ctre/phoenix6/controls/DynamicMotionMagicExpoVoltage.hpp"
29#include "ctre/phoenix6/controls/DifferentialDutyCycle.hpp"
30#include "ctre/phoenix6/controls/DifferentialVoltage.hpp"
31#include "ctre/phoenix6/controls/DifferentialPositionDutyCycle.hpp"
32#include "ctre/phoenix6/controls/DifferentialPositionVoltage.hpp"
33#include "ctre/phoenix6/controls/DifferentialVelocityDutyCycle.hpp"
34#include "ctre/phoenix6/controls/DifferentialVelocityVoltage.hpp"
35#include "ctre/phoenix6/controls/DifferentialMotionMagicDutyCycle.hpp"
36#include "ctre/phoenix6/controls/DifferentialMotionMagicVoltage.hpp"
37#include "ctre/phoenix6/controls/DifferentialMotionMagicExpoDutyCycle.hpp"
38#include "ctre/phoenix6/controls/DifferentialMotionMagicExpoVoltage.hpp"
39#include "ctre/phoenix6/controls/DifferentialMotionMagicVelocityDutyCycle.hpp"
40#include "ctre/phoenix6/controls/DifferentialMotionMagicVelocityVoltage.hpp"
41#include "ctre/phoenix6/controls/Follower.hpp"
42#include "ctre/phoenix6/controls/StrictFollower.hpp"
43#include "ctre/phoenix6/controls/DifferentialFollower.hpp"
44#include "ctre/phoenix6/controls/DifferentialStrictFollower.hpp"
45#include "ctre/phoenix6/controls/StaticBrake.hpp"
46#include "ctre/phoenix6/controls/NeutralOut.hpp"
47#include "ctre/phoenix6/controls/CoastOut.hpp"
48#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Position.hpp"
49#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Position.hpp"
50#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Position.hpp"
51#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Position.hpp"
52#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Position.hpp"
53#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Position.hpp"
54#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Velocity.hpp"
55#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Velocity.hpp"
56#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Velocity.hpp"
57#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Velocity.hpp"
58#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Velocity.hpp"
59#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Velocity.hpp"
60#include "ctre/phoenix6/controls/compound/Diff_DutyCycleOut_Open.hpp"
61#include "ctre/phoenix6/controls/compound/Diff_PositionDutyCycle_Open.hpp"
62#include "ctre/phoenix6/controls/compound/Diff_VelocityDutyCycle_Open.hpp"
63#include "ctre/phoenix6/controls/compound/Diff_MotionMagicDutyCycle_Open.hpp"
64#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoDutyCycle_Open.hpp"
65#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityDutyCycle_Open.hpp"
66#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Position.hpp"
67#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Position.hpp"
68#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Position.hpp"
69#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Position.hpp"
70#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Position.hpp"
71#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Position.hpp"
72#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Velocity.hpp"
73#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Velocity.hpp"
74#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Velocity.hpp"
75#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Velocity.hpp"
76#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Velocity.hpp"
77#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Velocity.hpp"
78#include "ctre/phoenix6/controls/compound/Diff_VoltageOut_Open.hpp"
79#include "ctre/phoenix6/controls/compound/Diff_PositionVoltage_Open.hpp"
80#include "ctre/phoenix6/controls/compound/Diff_VelocityVoltage_Open.hpp"
81#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVoltage_Open.hpp"
82#include "ctre/phoenix6/controls/compound/Diff_MotionMagicExpoVoltage_Open.hpp"
83#include "ctre/phoenix6/controls/compound/Diff_MotionMagicVelocityVoltage_Open.hpp"
84
85
86namespace ctre {
87namespace phoenix6 {
88namespace hardware {
89namespace traits {
90
91/**
92 * Contains all control functions available for devices that support Talon
93 * controls.
94 */
95class HasTalonControls : public virtual CommonDevice
96{
97public:
98 virtual ~HasTalonControls() = default;
99
100
101 /**
102 * \brief Request a specified motor duty cycle.
103 *
104 * \details This control mode will output a proportion of the supplied
105 * voltage which is supplied by the user.
106 *
107 * - DutyCycleOut Parameters:
108 * - Output: Proportion of supply voltage to apply in fractional units between
109 * -1 and +1
110 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
111 * which increases peak power by ~15% on supported devices (see
112 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
113 * commutation.
114 *
115 * FOC improves motor performance by leveraging torque (current)
116 * control. However, this may be inconvenient for applications
117 * that require specifying duty cycle or voltage.
118 * CTR-Electronics has developed a hybrid method that combines
119 * the performances gains of FOC while still allowing
120 * applications to provide duty cycle or voltage demand. This
121 * not to be confused with simple sinusoidal control or phase
122 * voltage control which lacks the performance gains.
123 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
124 * output is zero (or within deadband). Set to
125 * false to use the NeutralMode configuration
126 * setting (default). This flag exists to provide
127 * the fundamental behavior of this control when
128 * output is zero, which is to provide 0V to the
129 * motor.
130 * - LimitForwardMotion: Set to true to force forward limiting. This allows
131 * users to use other limit switch sensors connected to
132 * robot controller. This also allows use of active
133 * sensors that require external power.
134 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
135 * users to use other limit switch sensors connected to
136 * robot controller. This also allows use of active
137 * sensors that require external power.
138 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
139 * the LimitForwardMotion and LimitReverseMotion
140 * parameters, instead allowing motion.
141 *
142 * This can be useful on mechanisms such as an
143 * intake/feeder, where a limit switch stops motion
144 * while intaking but should be ignored when feeding
145 * to a shooter.
146 *
147 * The hardware limit faults and Forward/ReverseLimit
148 * signals will still report the values of the limit
149 * switches regardless of this parameter.
150 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
151 * allowing motion.
152 *
153 * This can be useful when calibrating the zero point
154 * of a mechanism such as an elevator.
155 *
156 * The software limit faults will still report the
157 * values of the software limits regardless of this
158 * parameter.
159 * - UseTimesync: Set to true to delay applying this control request until a
160 * timesync boundary (requires Phoenix Pro and CANivore). This
161 * eliminates the impact of nondeterministic network delays in
162 * exchange for a larger but deterministic control latency.
163 *
164 * This requires setting the ControlTimesyncFreqHz config in
165 * MotorOutputConfigs. Additionally, when this is enabled, the
166 * UpdateFreqHz of this request should be set to 0 Hz.
167 *
168 * \param request Control object to request of the device
169 * \returns Status Code of the request, 0 is OK
170 */
171 virtual ctre::phoenix::StatusCode SetControl(const controls::DutyCycleOut &request) = 0;
172
173 /**
174 * \brief Request a specified voltage.
175 *
176 * \details This control mode will attempt to apply the specified
177 * voltage to the motor. If the supply voltage is below the requested
178 * voltage, the motor controller will output the supply voltage.
179 *
180 * - VoltageOut Parameters:
181 * - Output: Voltage to attempt to drive at
182 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
183 * which increases peak power by ~15% on supported devices (see
184 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
185 * commutation.
186 *
187 * FOC improves motor performance by leveraging torque (current)
188 * control. However, this may be inconvenient for applications
189 * that require specifying duty cycle or voltage.
190 * CTR-Electronics has developed a hybrid method that combines
191 * the performances gains of FOC while still allowing
192 * applications to provide duty cycle or voltage demand. This
193 * not to be confused with simple sinusoidal control or phase
194 * voltage control which lacks the performance gains.
195 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
196 * output is zero (or within deadband). Set to
197 * false to use the NeutralMode configuration
198 * setting (default). This flag exists to provide
199 * the fundamental behavior of this control when
200 * output is zero, which is to provide 0V to the
201 * motor.
202 * - LimitForwardMotion: Set to true to force forward limiting. This allows
203 * users to use other limit switch sensors connected to
204 * robot controller. This also allows use of active
205 * sensors that require external power.
206 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
207 * users to use other limit switch sensors connected to
208 * robot controller. This also allows use of active
209 * sensors that require external power.
210 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
211 * the LimitForwardMotion and LimitReverseMotion
212 * parameters, instead allowing motion.
213 *
214 * This can be useful on mechanisms such as an
215 * intake/feeder, where a limit switch stops motion
216 * while intaking but should be ignored when feeding
217 * to a shooter.
218 *
219 * The hardware limit faults and Forward/ReverseLimit
220 * signals will still report the values of the limit
221 * switches regardless of this parameter.
222 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
223 * allowing motion.
224 *
225 * This can be useful when calibrating the zero point
226 * of a mechanism such as an elevator.
227 *
228 * The software limit faults will still report the
229 * values of the software limits regardless of this
230 * parameter.
231 * - UseTimesync: Set to true to delay applying this control request until a
232 * timesync boundary (requires Phoenix Pro and CANivore). This
233 * eliminates the impact of nondeterministic network delays in
234 * exchange for a larger but deterministic control latency.
235 *
236 * This requires setting the ControlTimesyncFreqHz config in
237 * MotorOutputConfigs. Additionally, when this is enabled, the
238 * UpdateFreqHz of this request should be set to 0 Hz.
239 *
240 * \param request Control object to request of the device
241 * \returns Status Code of the request, 0 is OK
242 */
243 virtual ctre::phoenix::StatusCode SetControl(const controls::VoltageOut &request) = 0;
244
245 /**
246 * \brief Request PID to target position with duty cycle feedforward.
247 *
248 * \details This control mode will set the motor's position setpoint
249 * to the position specified by the user. In addition, it will apply
250 * an additional duty cycle as an arbitrary feedforward value.
251 *
252 * - PositionDutyCycle Parameters:
253 * - Position: Position to drive toward in rotations.
254 * - Velocity: Velocity to drive toward in rotations per second. This is
255 * typically used for motion profiles generated by the robot
256 * program.
257 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
258 * which increases peak power by ~15% on supported devices (see
259 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
260 * commutation.
261 *
262 * FOC improves motor performance by leveraging torque (current)
263 * control. However, this may be inconvenient for applications
264 * that require specifying duty cycle or voltage.
265 * CTR-Electronics has developed a hybrid method that combines
266 * the performances gains of FOC while still allowing
267 * applications to provide duty cycle or voltage demand. This
268 * not to be confused with simple sinusoidal control or phase
269 * voltage control which lacks the performance gains.
270 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
271 * This is added to the output of the onboard feedforward
272 * terms.
273 * - Slot: Select which gains are applied by selecting the slot. Use the
274 * configuration api to set the gain values for the selected slot
275 * before enabling this feature. Slot must be within [0,2].
276 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
277 * output is zero (or within deadband). Set to
278 * false to use the NeutralMode configuration
279 * setting (default). This flag exists to provide
280 * the fundamental behavior of this control when
281 * output is zero, which is to provide 0V to the
282 * motor.
283 * - LimitForwardMotion: Set to true to force forward limiting. This allows
284 * users to use other limit switch sensors connected to
285 * robot controller. This also allows use of active
286 * sensors that require external power.
287 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
288 * users to use other limit switch sensors connected to
289 * robot controller. This also allows use of active
290 * sensors that require external power.
291 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
292 * the LimitForwardMotion and LimitReverseMotion
293 * parameters, instead allowing motion.
294 *
295 * This can be useful on mechanisms such as an
296 * intake/feeder, where a limit switch stops motion
297 * while intaking but should be ignored when feeding
298 * to a shooter.
299 *
300 * The hardware limit faults and Forward/ReverseLimit
301 * signals will still report the values of the limit
302 * switches regardless of this parameter.
303 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
304 * allowing motion.
305 *
306 * This can be useful when calibrating the zero point
307 * of a mechanism such as an elevator.
308 *
309 * The software limit faults will still report the
310 * values of the software limits regardless of this
311 * parameter.
312 * - UseTimesync: Set to true to delay applying this control request until a
313 * timesync boundary (requires Phoenix Pro and CANivore). This
314 * eliminates the impact of nondeterministic network delays in
315 * exchange for a larger but deterministic control latency.
316 *
317 * This requires setting the ControlTimesyncFreqHz config in
318 * MotorOutputConfigs. Additionally, when this is enabled, the
319 * UpdateFreqHz of this request should be set to 0 Hz.
320 *
321 * \param request Control object to request of the device
322 * \returns Status Code of the request, 0 is OK
323 */
324 virtual ctre::phoenix::StatusCode SetControl(const controls::PositionDutyCycle &request) = 0;
325
326 /**
327 * \brief Request PID to target position with voltage feedforward
328 *
329 * \details This control mode will set the motor's position setpoint
330 * to the position specified by the user. In addition, it will apply
331 * an additional voltage as an arbitrary feedforward value.
332 *
333 * - PositionVoltage Parameters:
334 * - Position: Position to drive toward in rotations.
335 * - Velocity: Velocity to drive toward in rotations per second. This is
336 * typically used for motion profiles generated by the robot
337 * program.
338 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
339 * which increases peak power by ~15% on supported devices (see
340 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
341 * commutation.
342 *
343 * FOC improves motor performance by leveraging torque (current)
344 * control. However, this may be inconvenient for applications
345 * that require specifying duty cycle or voltage.
346 * CTR-Electronics has developed a hybrid method that combines
347 * the performances gains of FOC while still allowing
348 * applications to provide duty cycle or voltage demand. This
349 * not to be confused with simple sinusoidal control or phase
350 * voltage control which lacks the performance gains.
351 * - FeedForward: Feedforward to apply in volts. This is added to the output
352 * of the onboard feedforward terms.
353 * - Slot: Select which gains are applied by selecting the slot. Use the
354 * configuration api to set the gain values for the selected slot
355 * before enabling this feature. Slot must be within [0,2].
356 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
357 * output is zero (or within deadband). Set to
358 * false to use the NeutralMode configuration
359 * setting (default). This flag exists to provide
360 * the fundamental behavior of this control when
361 * output is zero, which is to provide 0V to the
362 * motor.
363 * - LimitForwardMotion: Set to true to force forward limiting. This allows
364 * users to use other limit switch sensors connected to
365 * robot controller. This also allows use of active
366 * sensors that require external power.
367 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
368 * users to use other limit switch sensors connected to
369 * robot controller. This also allows use of active
370 * sensors that require external power.
371 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
372 * the LimitForwardMotion and LimitReverseMotion
373 * parameters, instead allowing motion.
374 *
375 * This can be useful on mechanisms such as an
376 * intake/feeder, where a limit switch stops motion
377 * while intaking but should be ignored when feeding
378 * to a shooter.
379 *
380 * The hardware limit faults and Forward/ReverseLimit
381 * signals will still report the values of the limit
382 * switches regardless of this parameter.
383 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
384 * allowing motion.
385 *
386 * This can be useful when calibrating the zero point
387 * of a mechanism such as an elevator.
388 *
389 * The software limit faults will still report the
390 * values of the software limits regardless of this
391 * parameter.
392 * - UseTimesync: Set to true to delay applying this control request until a
393 * timesync boundary (requires Phoenix Pro and CANivore). This
394 * eliminates the impact of nondeterministic network delays in
395 * exchange for a larger but deterministic control latency.
396 *
397 * This requires setting the ControlTimesyncFreqHz config in
398 * MotorOutputConfigs. Additionally, when this is enabled, the
399 * UpdateFreqHz of this request should be set to 0 Hz.
400 *
401 * \param request Control object to request of the device
402 * \returns Status Code of the request, 0 is OK
403 */
404 virtual ctre::phoenix::StatusCode SetControl(const controls::PositionVoltage &request) = 0;
405
406 /**
407 * \brief Request PID to target velocity with duty cycle feedforward.
408 *
409 * \details This control mode will set the motor's velocity setpoint
410 * to the velocity specified by the user. In addition, it will apply
411 * an additional voltage as an arbitrary feedforward value.
412 *
413 * - VelocityDutyCycle Parameters:
414 * - Velocity: Velocity to drive toward in rotations per second.
415 * - Acceleration: Acceleration to drive toward in rotations per second
416 * squared. This is typically used for motion profiles
417 * generated by the robot program.
418 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
419 * which increases peak power by ~15% on supported devices (see
420 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
421 * commutation.
422 *
423 * FOC improves motor performance by leveraging torque (current)
424 * control. However, this may be inconvenient for applications
425 * that require specifying duty cycle or voltage.
426 * CTR-Electronics has developed a hybrid method that combines
427 * the performances gains of FOC while still allowing
428 * applications to provide duty cycle or voltage demand. This
429 * not to be confused with simple sinusoidal control or phase
430 * voltage control which lacks the performance gains.
431 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
432 * This is added to the output of the onboard feedforward
433 * terms.
434 * - Slot: Select which gains are applied by selecting the slot. Use the
435 * configuration api to set the gain values for the selected slot
436 * before enabling this feature. Slot must be within [0,2].
437 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
438 * output is zero (or within deadband). Set to
439 * false to use the NeutralMode configuration
440 * setting (default). This flag exists to provide
441 * the fundamental behavior of this control when
442 * output is zero, which is to provide 0V to the
443 * motor.
444 * - LimitForwardMotion: Set to true to force forward limiting. This allows
445 * users to use other limit switch sensors connected to
446 * robot controller. This also allows use of active
447 * sensors that require external power.
448 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
449 * users to use other limit switch sensors connected to
450 * robot controller. This also allows use of active
451 * sensors that require external power.
452 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
453 * the LimitForwardMotion and LimitReverseMotion
454 * parameters, instead allowing motion.
455 *
456 * This can be useful on mechanisms such as an
457 * intake/feeder, where a limit switch stops motion
458 * while intaking but should be ignored when feeding
459 * to a shooter.
460 *
461 * The hardware limit faults and Forward/ReverseLimit
462 * signals will still report the values of the limit
463 * switches regardless of this parameter.
464 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
465 * allowing motion.
466 *
467 * This can be useful when calibrating the zero point
468 * of a mechanism such as an elevator.
469 *
470 * The software limit faults will still report the
471 * values of the software limits regardless of this
472 * parameter.
473 * - UseTimesync: Set to true to delay applying this control request until a
474 * timesync boundary (requires Phoenix Pro and CANivore). This
475 * eliminates the impact of nondeterministic network delays in
476 * exchange for a larger but deterministic control latency.
477 *
478 * This requires setting the ControlTimesyncFreqHz config in
479 * MotorOutputConfigs. Additionally, when this is enabled, the
480 * UpdateFreqHz of this request should be set to 0 Hz.
481 *
482 * \param request Control object to request of the device
483 * \returns Status Code of the request, 0 is OK
484 */
485 virtual ctre::phoenix::StatusCode SetControl(const controls::VelocityDutyCycle &request) = 0;
486
487 /**
488 * \brief Request PID to target velocity with voltage feedforward.
489 *
490 * \details This control mode will set the motor's velocity setpoint
491 * to the velocity specified by the user. In addition, it will apply
492 * an additional voltage as an arbitrary feedforward value.
493 *
494 * - VelocityVoltage Parameters:
495 * - Velocity: Velocity to drive toward in rotations per second.
496 * - Acceleration: Acceleration to drive toward in rotations per second
497 * squared. This is typically used for motion profiles
498 * generated by the robot program.
499 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
500 * which increases peak power by ~15% on supported devices (see
501 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
502 * commutation.
503 *
504 * FOC improves motor performance by leveraging torque (current)
505 * control. However, this may be inconvenient for applications
506 * that require specifying duty cycle or voltage.
507 * CTR-Electronics has developed a hybrid method that combines
508 * the performances gains of FOC while still allowing
509 * applications to provide duty cycle or voltage demand. This
510 * not to be confused with simple sinusoidal control or phase
511 * voltage control which lacks the performance gains.
512 * - FeedForward: Feedforward to apply in volts This is added to the output of
513 * the onboard feedforward terms.
514 * - Slot: Select which gains are applied by selecting the slot. Use the
515 * configuration api to set the gain values for the selected slot
516 * before enabling this feature. Slot must be within [0,2].
517 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
518 * output is zero (or within deadband). Set to
519 * false to use the NeutralMode configuration
520 * setting (default). This flag exists to provide
521 * the fundamental behavior of this control when
522 * output is zero, which is to provide 0V to the
523 * motor.
524 * - LimitForwardMotion: Set to true to force forward limiting. This allows
525 * users to use other limit switch sensors connected to
526 * robot controller. This also allows use of active
527 * sensors that require external power.
528 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
529 * users to use other limit switch sensors connected to
530 * robot controller. This also allows use of active
531 * sensors that require external power.
532 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
533 * the LimitForwardMotion and LimitReverseMotion
534 * parameters, instead allowing motion.
535 *
536 * This can be useful on mechanisms such as an
537 * intake/feeder, where a limit switch stops motion
538 * while intaking but should be ignored when feeding
539 * to a shooter.
540 *
541 * The hardware limit faults and Forward/ReverseLimit
542 * signals will still report the values of the limit
543 * switches regardless of this parameter.
544 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
545 * allowing motion.
546 *
547 * This can be useful when calibrating the zero point
548 * of a mechanism such as an elevator.
549 *
550 * The software limit faults will still report the
551 * values of the software limits regardless of this
552 * parameter.
553 * - UseTimesync: Set to true to delay applying this control request until a
554 * timesync boundary (requires Phoenix Pro and CANivore). This
555 * eliminates the impact of nondeterministic network delays in
556 * exchange for a larger but deterministic control latency.
557 *
558 * This requires setting the ControlTimesyncFreqHz config in
559 * MotorOutputConfigs. Additionally, when this is enabled, the
560 * UpdateFreqHz of this request should be set to 0 Hz.
561 *
562 * \param request Control object to request of the device
563 * \returns Status Code of the request, 0 is OK
564 */
565 virtual ctre::phoenix::StatusCode SetControl(const controls::VelocityVoltage &request) = 0;
566
567 /**
568 * \brief Requests Motion Magic® to target a final position using a
569 * motion profile. Users can optionally provide a duty cycle
570 * feedforward.
571 *
572 * \details Motion Magic® produces a motion profile in real-time while
573 * attempting to honor the Cruise Velocity, Acceleration, and
574 * (optional) Jerk specified via the Motion Magic® configuration
575 * values. This control mode does not use the Expo_kV or Expo_kA
576 * configs.
577 *
578 * Target position can be changed on-the-fly and Motion Magic® will do
579 * its best to adjust the profile. This control mode is duty cycle
580 * based, so relevant closed-loop gains will use fractional duty cycle
581 * for the numerator: +1.0 represents full forward output.
582 *
583 * - MotionMagicDutyCycle Parameters:
584 * - Position: Position to drive toward in rotations.
585 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
586 * which increases peak power by ~15% on supported devices (see
587 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
588 * commutation.
589 *
590 * FOC improves motor performance by leveraging torque (current)
591 * control. However, this may be inconvenient for applications
592 * that require specifying duty cycle or voltage.
593 * CTR-Electronics has developed a hybrid method that combines
594 * the performances gains of FOC while still allowing
595 * applications to provide duty cycle or voltage demand. This
596 * not to be confused with simple sinusoidal control or phase
597 * voltage control which lacks the performance gains.
598 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
599 * This is added to the output of the onboard feedforward
600 * terms.
601 * - Slot: Select which gains are applied by selecting the slot. Use the
602 * configuration api to set the gain values for the selected slot
603 * before enabling this feature. Slot must be within [0,2].
604 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
605 * output is zero (or within deadband). Set to
606 * false to use the NeutralMode configuration
607 * setting (default). This flag exists to provide
608 * the fundamental behavior of this control when
609 * output is zero, which is to provide 0V to the
610 * motor.
611 * - LimitForwardMotion: Set to true to force forward limiting. This allows
612 * users to use other limit switch sensors connected to
613 * robot controller. This also allows use of active
614 * sensors that require external power.
615 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
616 * users to use other limit switch sensors connected to
617 * robot controller. This also allows use of active
618 * sensors that require external power.
619 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
620 * the LimitForwardMotion and LimitReverseMotion
621 * parameters, instead allowing motion.
622 *
623 * This can be useful on mechanisms such as an
624 * intake/feeder, where a limit switch stops motion
625 * while intaking but should be ignored when feeding
626 * to a shooter.
627 *
628 * The hardware limit faults and Forward/ReverseLimit
629 * signals will still report the values of the limit
630 * switches regardless of this parameter.
631 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
632 * allowing motion.
633 *
634 * This can be useful when calibrating the zero point
635 * of a mechanism such as an elevator.
636 *
637 * The software limit faults will still report the
638 * values of the software limits regardless of this
639 * parameter.
640 * - UseTimesync: Set to true to delay applying this control request until a
641 * timesync boundary (requires Phoenix Pro and CANivore). This
642 * eliminates the impact of nondeterministic network delays in
643 * exchange for a larger but deterministic control latency.
644 *
645 * This requires setting the ControlTimesyncFreqHz config in
646 * MotorOutputConfigs. Additionally, when this is enabled, the
647 * UpdateFreqHz of this request should be set to 0 Hz.
648 *
649 * \param request Control object to request of the device
650 * \returns Status Code of the request, 0 is OK
651 */
652 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicDutyCycle &request) = 0;
653
654 /**
655 * \brief Requests Motion Magic® to target a final position using a
656 * motion profile. Users can optionally provide a voltage
657 * feedforward.
658 *
659 * \details Motion Magic® produces a motion profile in real-time while
660 * attempting to honor the Cruise Velocity, Acceleration, and
661 * (optional) Jerk specified via the Motion Magic® configuration
662 * values. This control mode does not use the Expo_kV or Expo_kA
663 * configs.
664 *
665 * Target position can be changed on-the-fly and Motion Magic® will do
666 * its best to adjust the profile. This control mode is
667 * voltage-based, so relevant closed-loop gains will use Volts for the
668 * numerator.
669 *
670 * - MotionMagicVoltage Parameters:
671 * - Position: Position to drive toward in rotations.
672 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
673 * which increases peak power by ~15% on supported devices (see
674 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
675 * commutation.
676 *
677 * FOC improves motor performance by leveraging torque (current)
678 * control. However, this may be inconvenient for applications
679 * that require specifying duty cycle or voltage.
680 * CTR-Electronics has developed a hybrid method that combines
681 * the performances gains of FOC while still allowing
682 * applications to provide duty cycle or voltage demand. This
683 * not to be confused with simple sinusoidal control or phase
684 * voltage control which lacks the performance gains.
685 * - FeedForward: Feedforward to apply in volts. This is added to the output
686 * of the onboard feedforward terms.
687 * - Slot: Select which gains are applied by selecting the slot. Use the
688 * configuration api to set the gain values for the selected slot
689 * before enabling this feature. Slot must be within [0,2].
690 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
691 * output is zero (or within deadband). Set to
692 * false to use the NeutralMode configuration
693 * setting (default). This flag exists to provide
694 * the fundamental behavior of this control when
695 * output is zero, which is to provide 0V to the
696 * motor.
697 * - LimitForwardMotion: Set to true to force forward limiting. This allows
698 * users to use other limit switch sensors connected to
699 * robot controller. This also allows use of active
700 * sensors that require external power.
701 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
702 * users to use other limit switch sensors connected to
703 * robot controller. This also allows use of active
704 * sensors that require external power.
705 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
706 * the LimitForwardMotion and LimitReverseMotion
707 * parameters, instead allowing motion.
708 *
709 * This can be useful on mechanisms such as an
710 * intake/feeder, where a limit switch stops motion
711 * while intaking but should be ignored when feeding
712 * to a shooter.
713 *
714 * The hardware limit faults and Forward/ReverseLimit
715 * signals will still report the values of the limit
716 * switches regardless of this parameter.
717 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
718 * allowing motion.
719 *
720 * This can be useful when calibrating the zero point
721 * of a mechanism such as an elevator.
722 *
723 * The software limit faults will still report the
724 * values of the software limits regardless of this
725 * parameter.
726 * - UseTimesync: Set to true to delay applying this control request until a
727 * timesync boundary (requires Phoenix Pro and CANivore). This
728 * eliminates the impact of nondeterministic network delays in
729 * exchange for a larger but deterministic control latency.
730 *
731 * This requires setting the ControlTimesyncFreqHz config in
732 * MotorOutputConfigs. Additionally, when this is enabled, the
733 * UpdateFreqHz of this request should be set to 0 Hz.
734 *
735 * \param request Control object to request of the device
736 * \returns Status Code of the request, 0 is OK
737 */
738 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVoltage &request) = 0;
739
740 /**
741 * \brief Requests Motion Magic® to target a final velocity using a
742 * motion profile. This allows smooth transitions between velocity
743 * set points. Users can optionally provide a duty cycle feedforward.
744 *
745 * \details Motion Magic® Velocity produces a motion profile in
746 * real-time while attempting to honor the specified Acceleration and
747 * (optional) Jerk. This control mode does not use the
748 * CruiseVelocity, Expo_kV, or Expo_kA configs.
749 *
750 * If the specified acceleration is zero, the Acceleration under
751 * Motion Magic® configuration parameter is used instead. This allows
752 * for runtime adjustment of acceleration for advanced users. Jerk is
753 * also specified in the Motion Magic® persistent configuration
754 * values. If Jerk is set to zero, Motion Magic® will produce a
755 * trapezoidal acceleration profile.
756 *
757 * Target velocity can also be changed on-the-fly and Motion Magic®
758 * will do its best to adjust the profile. This control mode is duty
759 * cycle based, so relevant closed-loop gains will use fractional duty
760 * cycle for the numerator: +1.0 represents full forward output.
761 *
762 * - MotionMagicVelocityDutyCycle Parameters:
763 * - Velocity: Target velocity to drive toward in rotations per second. This
764 * can be changed on-the fly.
765 * - Acceleration: This is the absolute Acceleration to use generating the
766 * profile. If this parameter is zero, the Acceleration
767 * persistent configuration parameter is used instead.
768 * Acceleration is in rotations per second squared. If
769 * nonzero, the signage does not matter as the absolute value
770 * is used.
771 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
772 * which increases peak power by ~15% on supported devices (see
773 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
774 * commutation.
775 *
776 * FOC improves motor performance by leveraging torque (current)
777 * control. However, this may be inconvenient for applications
778 * that require specifying duty cycle or voltage.
779 * CTR-Electronics has developed a hybrid method that combines
780 * the performances gains of FOC while still allowing
781 * applications to provide duty cycle or voltage demand. This
782 * not to be confused with simple sinusoidal control or phase
783 * voltage control which lacks the performance gains.
784 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
785 * This is added to the output of the onboard feedforward
786 * terms.
787 * - Slot: Select which gains are applied by selecting the slot. Use the
788 * configuration api to set the gain values for the selected slot
789 * before enabling this feature. Slot must be within [0,2].
790 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
791 * output is zero (or within deadband). Set to
792 * false to use the NeutralMode configuration
793 * setting (default). This flag exists to provide
794 * the fundamental behavior of this control when
795 * output is zero, which is to provide 0V to the
796 * motor.
797 * - LimitForwardMotion: Set to true to force forward limiting. This allows
798 * users to use other limit switch sensors connected to
799 * robot controller. This also allows use of active
800 * sensors that require external power.
801 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
802 * users to use other limit switch sensors connected to
803 * robot controller. This also allows use of active
804 * sensors that require external power.
805 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
806 * the LimitForwardMotion and LimitReverseMotion
807 * parameters, instead allowing motion.
808 *
809 * This can be useful on mechanisms such as an
810 * intake/feeder, where a limit switch stops motion
811 * while intaking but should be ignored when feeding
812 * to a shooter.
813 *
814 * The hardware limit faults and Forward/ReverseLimit
815 * signals will still report the values of the limit
816 * switches regardless of this parameter.
817 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
818 * allowing motion.
819 *
820 * This can be useful when calibrating the zero point
821 * of a mechanism such as an elevator.
822 *
823 * The software limit faults will still report the
824 * values of the software limits regardless of this
825 * parameter.
826 * - UseTimesync: Set to true to delay applying this control request until a
827 * timesync boundary (requires Phoenix Pro and CANivore). This
828 * eliminates the impact of nondeterministic network delays in
829 * exchange for a larger but deterministic control latency.
830 *
831 * This requires setting the ControlTimesyncFreqHz config in
832 * MotorOutputConfigs. Additionally, when this is enabled, the
833 * UpdateFreqHz of this request should be set to 0 Hz.
834 *
835 * \param request Control object to request of the device
836 * \returns Status Code of the request, 0 is OK
837 */
838 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVelocityDutyCycle &request) = 0;
839
840 /**
841 * \brief Requests Motion Magic® to target a final velocity using a
842 * motion profile. This allows smooth transitions between velocity
843 * set points. Users can optionally provide a voltage feedforward.
844 *
845 * \details Motion Magic® Velocity produces a motion profile in
846 * real-time while attempting to honor the specified Acceleration and
847 * (optional) Jerk. This control mode does not use the
848 * CruiseVelocity, Expo_kV, or Expo_kA configs.
849 *
850 * If the specified acceleration is zero, the Acceleration under
851 * Motion Magic® configuration parameter is used instead. This allows
852 * for runtime adjustment of acceleration for advanced users. Jerk is
853 * also specified in the Motion Magic® persistent configuration
854 * values. If Jerk is set to zero, Motion Magic® will produce a
855 * trapezoidal acceleration profile.
856 *
857 * Target velocity can also be changed on-the-fly and Motion Magic®
858 * will do its best to adjust the profile. This control mode is
859 * voltage-based, so relevant closed-loop gains will use Volts for the
860 * numerator.
861 *
862 * - MotionMagicVelocityVoltage Parameters:
863 * - Velocity: Target velocity to drive toward in rotations per second. This
864 * can be changed on-the fly.
865 * - Acceleration: This is the absolute Acceleration to use generating the
866 * profile. If this parameter is zero, the Acceleration
867 * persistent configuration parameter is used instead.
868 * Acceleration is in rotations per second squared. If
869 * nonzero, the signage does not matter as the absolute value
870 * is used.
871 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
872 * which increases peak power by ~15% on supported devices (see
873 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
874 * commutation.
875 *
876 * FOC improves motor performance by leveraging torque (current)
877 * control. However, this may be inconvenient for applications
878 * that require specifying duty cycle or voltage.
879 * CTR-Electronics has developed a hybrid method that combines
880 * the performances gains of FOC while still allowing
881 * applications to provide duty cycle or voltage demand. This
882 * not to be confused with simple sinusoidal control or phase
883 * voltage control which lacks the performance gains.
884 * - FeedForward: Feedforward to apply in volts. This is added to the output
885 * of the onboard feedforward terms.
886 * - Slot: Select which gains are applied by selecting the slot. Use the
887 * configuration api to set the gain values for the selected slot
888 * before enabling this feature. Slot must be within [0,2].
889 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
890 * output is zero (or within deadband). Set to
891 * false to use the NeutralMode configuration
892 * setting (default). This flag exists to provide
893 * the fundamental behavior of this control when
894 * output is zero, which is to provide 0V to the
895 * motor.
896 * - LimitForwardMotion: Set to true to force forward limiting. This allows
897 * users to use other limit switch sensors connected to
898 * robot controller. This also allows use of active
899 * sensors that require external power.
900 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
901 * users to use other limit switch sensors connected to
902 * robot controller. This also allows use of active
903 * sensors that require external power.
904 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
905 * the LimitForwardMotion and LimitReverseMotion
906 * parameters, instead allowing motion.
907 *
908 * This can be useful on mechanisms such as an
909 * intake/feeder, where a limit switch stops motion
910 * while intaking but should be ignored when feeding
911 * to a shooter.
912 *
913 * The hardware limit faults and Forward/ReverseLimit
914 * signals will still report the values of the limit
915 * switches regardless of this parameter.
916 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
917 * allowing motion.
918 *
919 * This can be useful when calibrating the zero point
920 * of a mechanism such as an elevator.
921 *
922 * The software limit faults will still report the
923 * values of the software limits regardless of this
924 * parameter.
925 * - UseTimesync: Set to true to delay applying this control request until a
926 * timesync boundary (requires Phoenix Pro and CANivore). This
927 * eliminates the impact of nondeterministic network delays in
928 * exchange for a larger but deterministic control latency.
929 *
930 * This requires setting the ControlTimesyncFreqHz config in
931 * MotorOutputConfigs. Additionally, when this is enabled, the
932 * UpdateFreqHz of this request should be set to 0 Hz.
933 *
934 * \param request Control object to request of the device
935 * \returns Status Code of the request, 0 is OK
936 */
937 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVelocityVoltage &request) = 0;
938
939 /**
940 * \brief Requests Motion Magic® to target a final position using an
941 * exponential motion profile. Users can optionally provide a duty
942 * cycle feedforward.
943 *
944 * \details Motion Magic® Expo produces a motion profile in real-time
945 * while attempting to honor the Cruise Velocity (optional) and the
946 * mechanism kV and kA, specified via the Motion Magic® configuration
947 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
948 * configs are always in output units of Volts.
949 *
950 * Setting Cruise Velocity to 0 will allow the profile to run to the
951 * max possible velocity based on Expo_kV. This control mode does not
952 * use the Acceleration or Jerk configs.
953 *
954 * Target position can be changed on-the-fly and Motion Magic® will do
955 * its best to adjust the profile. This control mode is duty cycle
956 * based, so relevant closed-loop gains will use fractional duty cycle
957 * for the numerator: +1.0 represents full forward output.
958 *
959 * - MotionMagicExpoDutyCycle Parameters:
960 * - Position: Position to drive toward in rotations.
961 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
962 * which increases peak power by ~15% on supported devices (see
963 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
964 * commutation.
965 *
966 * FOC improves motor performance by leveraging torque (current)
967 * control. However, this may be inconvenient for applications
968 * that require specifying duty cycle or voltage.
969 * CTR-Electronics has developed a hybrid method that combines
970 * the performances gains of FOC while still allowing
971 * applications to provide duty cycle or voltage demand. This
972 * not to be confused with simple sinusoidal control or phase
973 * voltage control which lacks the performance gains.
974 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
975 * This is added to the output of the onboard feedforward
976 * terms.
977 * - Slot: Select which gains are applied by selecting the slot. Use the
978 * configuration api to set the gain values for the selected slot
979 * before enabling this feature. Slot must be within [0,2].
980 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
981 * output is zero (or within deadband). Set to
982 * false to use the NeutralMode configuration
983 * setting (default). This flag exists to provide
984 * the fundamental behavior of this control when
985 * output is zero, which is to provide 0V to the
986 * motor.
987 * - LimitForwardMotion: Set to true to force forward limiting. This allows
988 * users to use other limit switch sensors connected to
989 * robot controller. This also allows use of active
990 * sensors that require external power.
991 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
992 * users to use other limit switch sensors connected to
993 * robot controller. This also allows use of active
994 * sensors that require external power.
995 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
996 * the LimitForwardMotion and LimitReverseMotion
997 * parameters, instead allowing motion.
998 *
999 * This can be useful on mechanisms such as an
1000 * intake/feeder, where a limit switch stops motion
1001 * while intaking but should be ignored when feeding
1002 * to a shooter.
1003 *
1004 * The hardware limit faults and Forward/ReverseLimit
1005 * signals will still report the values of the limit
1006 * switches regardless of this parameter.
1007 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1008 * allowing motion.
1009 *
1010 * This can be useful when calibrating the zero point
1011 * of a mechanism such as an elevator.
1012 *
1013 * The software limit faults will still report the
1014 * values of the software limits regardless of this
1015 * parameter.
1016 * - UseTimesync: Set to true to delay applying this control request until a
1017 * timesync boundary (requires Phoenix Pro and CANivore). This
1018 * eliminates the impact of nondeterministic network delays in
1019 * exchange for a larger but deterministic control latency.
1020 *
1021 * This requires setting the ControlTimesyncFreqHz config in
1022 * MotorOutputConfigs. Additionally, when this is enabled, the
1023 * UpdateFreqHz of this request should be set to 0 Hz.
1024 *
1025 * \param request Control object to request of the device
1026 * \returns Status Code of the request, 0 is OK
1027 */
1028 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicExpoDutyCycle &request) = 0;
1029
1030 /**
1031 * \brief Requests Motion Magic® to target a final position using an
1032 * exponential motion profile. Users can optionally provide a voltage
1033 * feedforward.
1034 *
1035 * \details Motion Magic® Expo produces a motion profile in real-time
1036 * while attempting to honor the Cruise Velocity (optional) and the
1037 * mechanism kV and kA, specified via the Motion Magic® configuration
1038 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
1039 * configs are always in output units of Volts.
1040 *
1041 * Setting Cruise Velocity to 0 will allow the profile to run to the
1042 * max possible velocity based on Expo_kV. This control mode does not
1043 * use the Acceleration or Jerk configs.
1044 *
1045 * Target position can be changed on-the-fly and Motion Magic® will do
1046 * its best to adjust the profile. This control mode is
1047 * voltage-based, so relevant closed-loop gains will use Volts for the
1048 * numerator.
1049 *
1050 * - MotionMagicExpoVoltage Parameters:
1051 * - Position: Position to drive toward in rotations.
1052 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1053 * which increases peak power by ~15% on supported devices (see
1054 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1055 * commutation.
1056 *
1057 * FOC improves motor performance by leveraging torque (current)
1058 * control. However, this may be inconvenient for applications
1059 * that require specifying duty cycle or voltage.
1060 * CTR-Electronics has developed a hybrid method that combines
1061 * the performances gains of FOC while still allowing
1062 * applications to provide duty cycle or voltage demand. This
1063 * not to be confused with simple sinusoidal control or phase
1064 * voltage control which lacks the performance gains.
1065 * - FeedForward: Feedforward to apply in volts. This is added to the output
1066 * of the onboard feedforward terms.
1067 * - Slot: Select which gains are applied by selecting the slot. Use the
1068 * configuration api to set the gain values for the selected slot
1069 * before enabling this feature. Slot must be within [0,2].
1070 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1071 * output is zero (or within deadband). Set to
1072 * false to use the NeutralMode configuration
1073 * setting (default). This flag exists to provide
1074 * the fundamental behavior of this control when
1075 * output is zero, which is to provide 0V to the
1076 * motor.
1077 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1078 * users to use other limit switch sensors connected to
1079 * robot controller. This also allows use of active
1080 * sensors that require external power.
1081 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1082 * users to use other limit switch sensors connected to
1083 * robot controller. This also allows use of active
1084 * sensors that require external power.
1085 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1086 * the LimitForwardMotion and LimitReverseMotion
1087 * parameters, instead allowing motion.
1088 *
1089 * This can be useful on mechanisms such as an
1090 * intake/feeder, where a limit switch stops motion
1091 * while intaking but should be ignored when feeding
1092 * to a shooter.
1093 *
1094 * The hardware limit faults and Forward/ReverseLimit
1095 * signals will still report the values of the limit
1096 * switches regardless of this parameter.
1097 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1098 * allowing motion.
1099 *
1100 * This can be useful when calibrating the zero point
1101 * of a mechanism such as an elevator.
1102 *
1103 * The software limit faults will still report the
1104 * values of the software limits regardless of this
1105 * parameter.
1106 * - UseTimesync: Set to true to delay applying this control request until a
1107 * timesync boundary (requires Phoenix Pro and CANivore). This
1108 * eliminates the impact of nondeterministic network delays in
1109 * exchange for a larger but deterministic control latency.
1110 *
1111 * This requires setting the ControlTimesyncFreqHz config in
1112 * MotorOutputConfigs. Additionally, when this is enabled, the
1113 * UpdateFreqHz of this request should be set to 0 Hz.
1114 *
1115 * \param request Control object to request of the device
1116 * \returns Status Code of the request, 0 is OK
1117 */
1118 virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicExpoVoltage &request) = 0;
1119
1120 /**
1121 * \brief Requests Motion Magic® to target a final position using a
1122 * motion profile. This dynamic request allows runtime changes to
1123 * Cruise Velocity, Acceleration, and (optional) Jerk. Users can
1124 * optionally provide a duty cycle feedforward.
1125 *
1126 * \details Motion Magic® produces a motion profile in real-time while
1127 * attempting to honor the specified Cruise Velocity, Acceleration,
1128 * and (optional) Jerk. This control mode does not use the Expo_kV or
1129 * Expo_kA configs.
1130 *
1131 * Target position can be changed on-the-fly and Motion Magic® will do
1132 * its best to adjust the profile. This control mode is duty cycle
1133 * based, so relevant closed-loop gains will use fractional duty cycle
1134 * for the numerator: +1.0 represents full forward output.
1135 *
1136 * - DynamicMotionMagicDutyCycle Parameters:
1137 * - Position: Position to drive toward in rotations.
1138 * - Velocity: Cruise velocity for profiling. The signage does not matter as
1139 * the device will use the absolute value for profile generation.
1140 * - Acceleration: Acceleration for profiling. The signage does not matter as
1141 * the device will use the absolute value for profile
1142 * generation
1143 * - Jerk: Jerk for profiling. The signage does not matter as the device will
1144 * use the absolute value for profile generation.
1145 *
1146 * Jerk is optional; if this is set to zero, then Motion Magic® will
1147 * not apply a Jerk limit.
1148 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1149 * which increases peak power by ~15% on supported devices (see
1150 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1151 * commutation.
1152 *
1153 * FOC improves motor performance by leveraging torque (current)
1154 * control. However, this may be inconvenient for applications
1155 * that require specifying duty cycle or voltage.
1156 * CTR-Electronics has developed a hybrid method that combines
1157 * the performances gains of FOC while still allowing
1158 * applications to provide duty cycle or voltage demand. This
1159 * not to be confused with simple sinusoidal control or phase
1160 * voltage control which lacks the performance gains.
1161 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
1162 * This is added to the output of the onboard feedforward
1163 * terms.
1164 * - Slot: Select which gains are applied by selecting the slot. Use the
1165 * configuration api to set the gain values for the selected slot
1166 * before enabling this feature. Slot must be within [0,2].
1167 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1168 * output is zero (or within deadband). Set to
1169 * false to use the NeutralMode configuration
1170 * setting (default). This flag exists to provide
1171 * the fundamental behavior of this control when
1172 * output is zero, which is to provide 0V to the
1173 * motor.
1174 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1175 * users to use other limit switch sensors connected to
1176 * robot controller. This also allows use of active
1177 * sensors that require external power.
1178 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1179 * users to use other limit switch sensors connected to
1180 * robot controller. This also allows use of active
1181 * sensors that require external power.
1182 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1183 * the LimitForwardMotion and LimitReverseMotion
1184 * parameters, instead allowing motion.
1185 *
1186 * This can be useful on mechanisms such as an
1187 * intake/feeder, where a limit switch stops motion
1188 * while intaking but should be ignored when feeding
1189 * to a shooter.
1190 *
1191 * The hardware limit faults and Forward/ReverseLimit
1192 * signals will still report the values of the limit
1193 * switches regardless of this parameter.
1194 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1195 * allowing motion.
1196 *
1197 * This can be useful when calibrating the zero point
1198 * of a mechanism such as an elevator.
1199 *
1200 * The software limit faults will still report the
1201 * values of the software limits regardless of this
1202 * parameter.
1203 * - UseTimesync: Set to true to delay applying this control request until a
1204 * timesync boundary (requires Phoenix Pro and CANivore). This
1205 * eliminates the impact of nondeterministic network delays in
1206 * exchange for a larger but deterministic control latency.
1207 *
1208 * This requires setting the ControlTimesyncFreqHz config in
1209 * MotorOutputConfigs. Additionally, when this is enabled, the
1210 * UpdateFreqHz of this request should be set to 0 Hz.
1211 *
1212 * \param request Control object to request of the device
1213 * \returns Status Code of the request, 0 is OK
1214 */
1215 virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicDutyCycle &request) = 0;
1216
1217 /**
1218 * \brief Requests Motion Magic® to target a final position using a
1219 * motion profile. This dynamic request allows runtime changes to
1220 * Cruise Velocity, Acceleration, and (optional) Jerk. Users can
1221 * optionally provide a voltage feedforward.
1222 *
1223 * \details Motion Magic® produces a motion profile in real-time while
1224 * attempting to honor the specified Cruise Velocity, Acceleration,
1225 * and (optional) Jerk. This control mode does not use the Expo_kV or
1226 * Expo_kA configs.
1227 *
1228 * Target position can be changed on-the-fly and Motion Magic® will do
1229 * its best to adjust the profile. This control mode is
1230 * voltage-based, so relevant closed-loop gains will use Volts for the
1231 * numerator.
1232 *
1233 * - DynamicMotionMagicVoltage Parameters:
1234 * - Position: Position to drive toward in rotations.
1235 * - Velocity: Cruise velocity for profiling. The signage does not matter as
1236 * the device will use the absolute value for profile generation.
1237 * - Acceleration: Acceleration for profiling. The signage does not matter as
1238 * the device will use the absolute value for profile
1239 * generation.
1240 * - Jerk: Jerk for profiling. The signage does not matter as the device will
1241 * use the absolute value for profile generation.
1242 *
1243 * Jerk is optional; if this is set to zero, then Motion Magic® will
1244 * not apply a Jerk limit.
1245 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1246 * which increases peak power by ~15% on supported devices (see
1247 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1248 * commutation.
1249 *
1250 * FOC improves motor performance by leveraging torque (current)
1251 * control. However, this may be inconvenient for applications
1252 * that require specifying duty cycle or voltage.
1253 * CTR-Electronics has developed a hybrid method that combines
1254 * the performances gains of FOC while still allowing
1255 * applications to provide duty cycle or voltage demand. This
1256 * not to be confused with simple sinusoidal control or phase
1257 * voltage control which lacks the performance gains.
1258 * - FeedForward: Feedforward to apply in volts. This is added to the output
1259 * of the onboard feedforward terms.
1260 * - Slot: Select which gains are applied by selecting the slot. Use the
1261 * configuration api to set the gain values for the selected slot
1262 * before enabling this feature. Slot must be within [0,2].
1263 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1264 * output is zero (or within deadband). Set to
1265 * false to use the NeutralMode configuration
1266 * setting (default). This flag exists to provide
1267 * the fundamental behavior of this control when
1268 * output is zero, which is to provide 0V to the
1269 * motor.
1270 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1271 * users to use other limit switch sensors connected to
1272 * robot controller. This also allows use of active
1273 * sensors that require external power.
1274 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1275 * users to use other limit switch sensors connected to
1276 * robot controller. This also allows use of active
1277 * sensors that require external power.
1278 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1279 * the LimitForwardMotion and LimitReverseMotion
1280 * parameters, instead allowing motion.
1281 *
1282 * This can be useful on mechanisms such as an
1283 * intake/feeder, where a limit switch stops motion
1284 * while intaking but should be ignored when feeding
1285 * to a shooter.
1286 *
1287 * The hardware limit faults and Forward/ReverseLimit
1288 * signals will still report the values of the limit
1289 * switches regardless of this parameter.
1290 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1291 * allowing motion.
1292 *
1293 * This can be useful when calibrating the zero point
1294 * of a mechanism such as an elevator.
1295 *
1296 * The software limit faults will still report the
1297 * values of the software limits regardless of this
1298 * parameter.
1299 * - UseTimesync: Set to true to delay applying this control request until a
1300 * timesync boundary (requires Phoenix Pro and CANivore). This
1301 * eliminates the impact of nondeterministic network delays in
1302 * exchange for a larger but deterministic control latency.
1303 *
1304 * This requires setting the ControlTimesyncFreqHz config in
1305 * MotorOutputConfigs. Additionally, when this is enabled, the
1306 * UpdateFreqHz of this request should be set to 0 Hz.
1307 *
1308 * \param request Control object to request of the device
1309 * \returns Status Code of the request, 0 is OK
1310 */
1311 virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicVoltage &request) = 0;
1312
1313 /**
1314 * \brief Requests Motion Magic® Expo to target a final position using
1315 * an exponential motion profile. This dynamic request allows runtime
1316 * changes to the profile kV, kA, and (optional) Cruise Velocity.
1317 * Users can optionally provide a duty cycle feedforward.
1318 *
1319 * \details Motion Magic® Expo produces a motion profile in real-time
1320 * while attempting to honor the specified Cruise Velocity (optional)
1321 * and the mechanism kV and kA. Note that unlike the slot gains, the
1322 * Expo_kV and Expo_kA parameters are always in output units of Volts.
1323 *
1324 * Setting the Cruise Velocity to 0 will allow the profile to run to
1325 * the max possible velocity based on Expo_kV. This control mode does
1326 * not use the Acceleration or Jerk configs.
1327 *
1328 * Target position can be changed on-the-fly and Motion Magic® will do
1329 * its best to adjust the profile. This control mode is duty cycle
1330 * based, so relevant closed-loop gains will use fractional duty cycle
1331 * for the numerator: +1.0 represents full forward output.
1332 *
1333 * - DynamicMotionMagicExpoDutyCycle Parameters:
1334 * - Position: Position to drive toward in rotations.
1335 * - kV: Mechanism kV for profiling. Unlike the kV slot gain, this is always
1336 * in units of V/rps.
1337 *
1338 * This represents the amount of voltage necessary to hold a velocity.
1339 * In terms of the Motion Magic® Expo profile, a higher kV results in a
1340 * slower maximum velocity.
1341 * - kA: Mechanism kA for profiling. Unlike the kA slot gain, this is always
1342 * in units of V/rps².
1343 *
1344 * This represents the amount of voltage necessary to achieve an
1345 * acceleration. In terms of the Motion Magic® Expo profile, a higher
1346 * kA results in a slower acceleration.
1347 * - Velocity: Cruise velocity for profiling. The signage does not matter as
1348 * the device will use the absolute value for profile generation.
1349 * Setting this to 0 will allow the profile to run to the max
1350 * possible velocity based on Expo_kV.
1351 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1352 * which increases peak power by ~15% on supported devices (see
1353 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1354 * commutation.
1355 *
1356 * FOC improves motor performance by leveraging torque (current)
1357 * control. However, this may be inconvenient for applications
1358 * that require specifying duty cycle or voltage.
1359 * CTR-Electronics has developed a hybrid method that combines
1360 * the performances gains of FOC while still allowing
1361 * applications to provide duty cycle or voltage demand. This
1362 * not to be confused with simple sinusoidal control or phase
1363 * voltage control which lacks the performance gains.
1364 * - FeedForward: Feedforward to apply in fractional units between -1 and +1.
1365 * This is added to the output of the onboard feedforward
1366 * terms.
1367 * - Slot: Select which gains are applied by selecting the slot. Use the
1368 * configuration api to set the gain values for the selected slot
1369 * before enabling this feature. Slot must be within [0,2].
1370 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1371 * output is zero (or within deadband). Set to
1372 * false to use the NeutralMode configuration
1373 * setting (default). This flag exists to provide
1374 * the fundamental behavior of this control when
1375 * output is zero, which is to provide 0V to the
1376 * motor.
1377 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1378 * users to use other limit switch sensors connected to
1379 * robot controller. This also allows use of active
1380 * sensors that require external power.
1381 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1382 * users to use other limit switch sensors connected to
1383 * robot controller. This also allows use of active
1384 * sensors that require external power.
1385 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1386 * the LimitForwardMotion and LimitReverseMotion
1387 * parameters, instead allowing motion.
1388 *
1389 * This can be useful on mechanisms such as an
1390 * intake/feeder, where a limit switch stops motion
1391 * while intaking but should be ignored when feeding
1392 * to a shooter.
1393 *
1394 * The hardware limit faults and Forward/ReverseLimit
1395 * signals will still report the values of the limit
1396 * switches regardless of this parameter.
1397 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1398 * allowing motion.
1399 *
1400 * This can be useful when calibrating the zero point
1401 * of a mechanism such as an elevator.
1402 *
1403 * The software limit faults will still report the
1404 * values of the software limits regardless of this
1405 * parameter.
1406 * - UseTimesync: Set to true to delay applying this control request until a
1407 * timesync boundary (requires Phoenix Pro and CANivore). This
1408 * eliminates the impact of nondeterministic network delays in
1409 * exchange for a larger but deterministic control latency.
1410 *
1411 * This requires setting the ControlTimesyncFreqHz config in
1412 * MotorOutputConfigs. Additionally, when this is enabled, the
1413 * UpdateFreqHz of this request should be set to 0 Hz.
1414 *
1415 * \param request Control object to request of the device
1416 * \returns Status Code of the request, 0 is OK
1417 */
1418 virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicExpoDutyCycle &request) = 0;
1419
1420 /**
1421 * \brief Requests Motion Magic® Expo to target a final position using
1422 * an exponential motion profile. This dynamic request allows runtime
1423 * changes to the profile kV, kA, and (optional) Cruise Velocity.
1424 * Users can optionally provide a voltage feedforward.
1425 *
1426 * \details Motion Magic® Expo produces a motion profile in real-time
1427 * while attempting to honor the specified Cruise Velocity (optional)
1428 * and the mechanism kV and kA. Note that unlike the slot gains, the
1429 * Expo_kV and Expo_kA parameters are always in output units of Volts.
1430 *
1431 * Setting the Cruise Velocity to 0 will allow the profile to run to
1432 * the max possible velocity based on Expo_kV. This control mode does
1433 * not use the Acceleration or Jerk configs.
1434 *
1435 * Target position can be changed on-the-fly and Motion Magic® will do
1436 * its best to adjust the profile. This control mode is
1437 * voltage-based, so relevant closed-loop gains will use Volts for the
1438 * numerator.
1439 *
1440 * - DynamicMotionMagicExpoVoltage Parameters:
1441 * - Position: Position to drive toward in rotations.
1442 * - kV: Mechanism kV for profiling. Unlike the kV slot gain, this is always
1443 * in units of V/rps.
1444 *
1445 * This represents the amount of voltage necessary to hold a velocity.
1446 * In terms of the Motion Magic® Expo profile, a higher kV results in a
1447 * slower maximum velocity.
1448 * - kA: Mechanism kA for profiling. Unlike the kA slot gain, this is always
1449 * in units of V/rps².
1450 *
1451 * This represents the amount of voltage necessary to achieve an
1452 * acceleration. In terms of the Motion Magic® Expo profile, a higher
1453 * kA results in a slower acceleration.
1454 * - Velocity: Cruise velocity for profiling. The signage does not matter as
1455 * the device will use the absolute value for profile generation.
1456 * Setting this to 0 will allow the profile to run to the max
1457 * possible velocity based on Expo_kV.
1458 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1459 * which increases peak power by ~15% on supported devices (see
1460 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1461 * commutation.
1462 *
1463 * FOC improves motor performance by leveraging torque (current)
1464 * control. However, this may be inconvenient for applications
1465 * that require specifying duty cycle or voltage.
1466 * CTR-Electronics has developed a hybrid method that combines
1467 * the performances gains of FOC while still allowing
1468 * applications to provide duty cycle or voltage demand. This
1469 * not to be confused with simple sinusoidal control or phase
1470 * voltage control which lacks the performance gains.
1471 * - FeedForward: Feedforward to apply in volts. This is added to the output
1472 * of the onboard feedforward terms.
1473 * - Slot: Select which gains are applied by selecting the slot. Use the
1474 * configuration api to set the gain values for the selected slot
1475 * before enabling this feature. Slot must be within [0,2].
1476 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1477 * output is zero (or within deadband). Set to
1478 * false to use the NeutralMode configuration
1479 * setting (default). This flag exists to provide
1480 * the fundamental behavior of this control when
1481 * output is zero, which is to provide 0V to the
1482 * motor.
1483 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1484 * users to use other limit switch sensors connected to
1485 * robot controller. This also allows use of active
1486 * sensors that require external power.
1487 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1488 * users to use other limit switch sensors connected to
1489 * robot controller. This also allows use of active
1490 * sensors that require external power.
1491 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1492 * the LimitForwardMotion and LimitReverseMotion
1493 * parameters, instead allowing motion.
1494 *
1495 * This can be useful on mechanisms such as an
1496 * intake/feeder, where a limit switch stops motion
1497 * while intaking but should be ignored when feeding
1498 * to a shooter.
1499 *
1500 * The hardware limit faults and Forward/ReverseLimit
1501 * signals will still report the values of the limit
1502 * switches regardless of this parameter.
1503 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1504 * allowing motion.
1505 *
1506 * This can be useful when calibrating the zero point
1507 * of a mechanism such as an elevator.
1508 *
1509 * The software limit faults will still report the
1510 * values of the software limits regardless of this
1511 * parameter.
1512 * - UseTimesync: Set to true to delay applying this control request until a
1513 * timesync boundary (requires Phoenix Pro and CANivore). This
1514 * eliminates the impact of nondeterministic network delays in
1515 * exchange for a larger but deterministic control latency.
1516 *
1517 * This requires setting the ControlTimesyncFreqHz config in
1518 * MotorOutputConfigs. Additionally, when this is enabled, the
1519 * UpdateFreqHz of this request should be set to 0 Hz.
1520 *
1521 * \param request Control object to request of the device
1522 * \returns Status Code of the request, 0 is OK
1523 */
1524 virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicExpoVoltage &request) = 0;
1525
1526 /**
1527 * \brief Request a specified motor duty cycle with a differential
1528 * position closed-loop.
1529 *
1530 * \details This control mode will output a proportion of the supplied
1531 * voltage which is supplied by the user. It will also set the motor's
1532 * differential position setpoint to the specified position.
1533 *
1534 * - DifferentialDutyCycle Parameters:
1535 * - AverageOutput: Proportion of supply voltage to apply on the Average axis
1536 * in fractional units between -1 and +1.
1537 * - DifferentialPosition: Differential position to drive towards in
1538 * rotations.
1539 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1540 * which increases peak power by ~15% on supported devices (see
1541 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1542 * commutation.
1543 *
1544 * FOC improves motor performance by leveraging torque (current)
1545 * control. However, this may be inconvenient for applications
1546 * that require specifying duty cycle or voltage.
1547 * CTR-Electronics has developed a hybrid method that combines
1548 * the performances gains of FOC while still allowing
1549 * applications to provide duty cycle or voltage demand. This
1550 * not to be confused with simple sinusoidal control or phase
1551 * voltage control which lacks the performance gains.
1552 * - DifferentialSlot: Select which gains are applied to the differential
1553 * controller by selecting the slot. Use the
1554 * configuration api to set the gain values for the
1555 * selected slot before enabling this feature. Slot must
1556 * be within [0,2].
1557 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1558 * output is zero (or within deadband). Set to
1559 * false to use the NeutralMode configuration
1560 * setting (default). This flag exists to provide
1561 * the fundamental behavior of this control when
1562 * output is zero, which is to provide 0V to the
1563 * motor.
1564 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1565 * users to use other limit switch sensors connected to
1566 * robot controller. This also allows use of active
1567 * sensors that require external power.
1568 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1569 * users to use other limit switch sensors connected to
1570 * robot controller. This also allows use of active
1571 * sensors that require external power.
1572 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1573 * the LimitForwardMotion and LimitReverseMotion
1574 * parameters, instead allowing motion.
1575 *
1576 * This can be useful on mechanisms such as an
1577 * intake/feeder, where a limit switch stops motion
1578 * while intaking but should be ignored when feeding
1579 * to a shooter.
1580 *
1581 * The hardware limit faults and Forward/ReverseLimit
1582 * signals will still report the values of the limit
1583 * switches regardless of this parameter.
1584 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1585 * allowing motion.
1586 *
1587 * This can be useful when calibrating the zero point
1588 * of a mechanism such as an elevator.
1589 *
1590 * The software limit faults will still report the
1591 * values of the software limits regardless of this
1592 * parameter.
1593 * - UseTimesync: Set to true to delay applying this control request until a
1594 * timesync boundary (requires Phoenix Pro and CANivore). This
1595 * eliminates the impact of nondeterministic network delays in
1596 * exchange for a larger but deterministic control latency.
1597 *
1598 * This requires setting the ControlTimesyncFreqHz config in
1599 * MotorOutputConfigs. Additionally, when this is enabled, the
1600 * UpdateFreqHz of this request should be set to 0 Hz.
1601 *
1602 * \param request Control object to request of the device
1603 * \returns Status Code of the request, 0 is OK
1604 */
1605 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialDutyCycle &request) = 0;
1606
1607 /**
1608 * \brief Request a specified voltage with a differential position
1609 * closed-loop.
1610 *
1611 * \details This control mode will attempt to apply the specified
1612 * voltage to the motor. If the supply voltage is below the requested
1613 * voltage, the motor controller will output the supply voltage. It
1614 * will also set the motor's differential position setpoint to the
1615 * specified position.
1616 *
1617 * - DifferentialVoltage Parameters:
1618 * - AverageOutput: Voltage to attempt to drive at on the Average axis.
1619 * - DifferentialPosition: Differential position to drive towards in
1620 * rotations.
1621 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1622 * which increases peak power by ~15% on supported devices (see
1623 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1624 * commutation.
1625 *
1626 * FOC improves motor performance by leveraging torque (current)
1627 * control. However, this may be inconvenient for applications
1628 * that require specifying duty cycle or voltage.
1629 * CTR-Electronics has developed a hybrid method that combines
1630 * the performances gains of FOC while still allowing
1631 * applications to provide duty cycle or voltage demand. This
1632 * not to be confused with simple sinusoidal control or phase
1633 * voltage control which lacks the performance gains.
1634 * - DifferentialSlot: Select which gains are applied to the differential
1635 * controller by selecting the slot. Use the
1636 * configuration api to set the gain values for the
1637 * selected slot before enabling this feature. Slot must
1638 * be within [0,2].
1639 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1640 * output is zero (or within deadband). Set to
1641 * false to use the NeutralMode configuration
1642 * setting (default). This flag exists to provide
1643 * the fundamental behavior of this control when
1644 * output is zero, which is to provide 0V to the
1645 * motor.
1646 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1647 * users to use other limit switch sensors connected to
1648 * robot controller. This also allows use of active
1649 * sensors that require external power.
1650 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1651 * users to use other limit switch sensors connected to
1652 * robot controller. This also allows use of active
1653 * sensors that require external power.
1654 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1655 * the LimitForwardMotion and LimitReverseMotion
1656 * parameters, instead allowing motion.
1657 *
1658 * This can be useful on mechanisms such as an
1659 * intake/feeder, where a limit switch stops motion
1660 * while intaking but should be ignored when feeding
1661 * to a shooter.
1662 *
1663 * The hardware limit faults and Forward/ReverseLimit
1664 * signals will still report the values of the limit
1665 * switches regardless of this parameter.
1666 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1667 * allowing motion.
1668 *
1669 * This can be useful when calibrating the zero point
1670 * of a mechanism such as an elevator.
1671 *
1672 * The software limit faults will still report the
1673 * values of the software limits regardless of this
1674 * parameter.
1675 * - UseTimesync: Set to true to delay applying this control request until a
1676 * timesync boundary (requires Phoenix Pro and CANivore). This
1677 * eliminates the impact of nondeterministic network delays in
1678 * exchange for a larger but deterministic control latency.
1679 *
1680 * This requires setting the ControlTimesyncFreqHz config in
1681 * MotorOutputConfigs. Additionally, when this is enabled, the
1682 * UpdateFreqHz of this request should be set to 0 Hz.
1683 *
1684 * \param request Control object to request of the device
1685 * \returns Status Code of the request, 0 is OK
1686 */
1687 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVoltage &request) = 0;
1688
1689 /**
1690 * \brief Request PID to target position with a differential position
1691 * setpoint.
1692 *
1693 * \details This control mode will set the motor's position setpoint
1694 * to the position specified by the user. It will also set the motor's
1695 * differential position setpoint to the specified position.
1696 *
1697 * - DifferentialPositionDutyCycle Parameters:
1698 * - AveragePosition: Average position to drive toward in rotations.
1699 * - DifferentialPosition: Differential position to drive toward in rotations.
1700 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1701 * which increases peak power by ~15% on supported devices (see
1702 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1703 * commutation.
1704 *
1705 * FOC improves motor performance by leveraging torque (current)
1706 * control. However, this may be inconvenient for applications
1707 * that require specifying duty cycle or voltage.
1708 * CTR-Electronics has developed a hybrid method that combines
1709 * the performances gains of FOC while still allowing
1710 * applications to provide duty cycle or voltage demand. This
1711 * not to be confused with simple sinusoidal control or phase
1712 * voltage control which lacks the performance gains.
1713 * - AverageSlot: Select which gains are applied to the average controller by
1714 * selecting the slot. Use the configuration api to set the
1715 * gain values for the selected slot before enabling this
1716 * feature. Slot must be within [0,2].
1717 * - DifferentialSlot: Select which gains are applied to the differential
1718 * controller by selecting the slot. Use the
1719 * configuration api to set the gain values for the
1720 * selected slot before enabling this feature. Slot must
1721 * be within [0,2].
1722 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1723 * output is zero (or within deadband). Set to
1724 * false to use the NeutralMode configuration
1725 * setting (default). This flag exists to provide
1726 * the fundamental behavior of this control when
1727 * output is zero, which is to provide 0V to the
1728 * motor.
1729 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1730 * users to use other limit switch sensors connected to
1731 * robot controller. This also allows use of active
1732 * sensors that require external power.
1733 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1734 * users to use other limit switch sensors connected to
1735 * robot controller. This also allows use of active
1736 * sensors that require external power.
1737 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1738 * the LimitForwardMotion and LimitReverseMotion
1739 * parameters, instead allowing motion.
1740 *
1741 * This can be useful on mechanisms such as an
1742 * intake/feeder, where a limit switch stops motion
1743 * while intaking but should be ignored when feeding
1744 * to a shooter.
1745 *
1746 * The hardware limit faults and Forward/ReverseLimit
1747 * signals will still report the values of the limit
1748 * switches regardless of this parameter.
1749 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1750 * allowing motion.
1751 *
1752 * This can be useful when calibrating the zero point
1753 * of a mechanism such as an elevator.
1754 *
1755 * The software limit faults will still report the
1756 * values of the software limits regardless of this
1757 * parameter.
1758 * - UseTimesync: Set to true to delay applying this control request until a
1759 * timesync boundary (requires Phoenix Pro and CANivore). This
1760 * eliminates the impact of nondeterministic network delays in
1761 * exchange for a larger but deterministic control latency.
1762 *
1763 * This requires setting the ControlTimesyncFreqHz config in
1764 * MotorOutputConfigs. Additionally, when this is enabled, the
1765 * UpdateFreqHz of this request should be set to 0 Hz.
1766 *
1767 * \param request Control object to request of the device
1768 * \returns Status Code of the request, 0 is OK
1769 */
1770 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialPositionDutyCycle &request) = 0;
1771
1772 /**
1773 * \brief Request PID to target position with a differential position
1774 * setpoint
1775 *
1776 * \details This control mode will set the motor's position setpoint
1777 * to the position specified by the user. It will also set the motor's
1778 * differential position setpoint to the specified position.
1779 *
1780 * - DifferentialPositionVoltage Parameters:
1781 * - AveragePosition: Average position to drive toward in rotations.
1782 * - DifferentialPosition: Differential position to drive toward in rotations.
1783 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1784 * which increases peak power by ~15% on supported devices (see
1785 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1786 * commutation.
1787 *
1788 * FOC improves motor performance by leveraging torque (current)
1789 * control. However, this may be inconvenient for applications
1790 * that require specifying duty cycle or voltage.
1791 * CTR-Electronics has developed a hybrid method that combines
1792 * the performances gains of FOC while still allowing
1793 * applications to provide duty cycle or voltage demand. This
1794 * not to be confused with simple sinusoidal control or phase
1795 * voltage control which lacks the performance gains.
1796 * - AverageSlot: Select which gains are applied to the average controller by
1797 * selecting the slot. Use the configuration api to set the
1798 * gain values for the selected slot before enabling this
1799 * feature. Slot must be within [0,2].
1800 * - DifferentialSlot: Select which gains are applied to the differential
1801 * controller by selecting the slot. Use the
1802 * configuration api to set the gain values for the
1803 * selected slot before enabling this feature. Slot must
1804 * be within [0,2].
1805 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1806 * output is zero (or within deadband). Set to
1807 * false to use the NeutralMode configuration
1808 * setting (default). This flag exists to provide
1809 * the fundamental behavior of this control when
1810 * output is zero, which is to provide 0V to the
1811 * motor.
1812 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1813 * users to use other limit switch sensors connected to
1814 * robot controller. This also allows use of active
1815 * sensors that require external power.
1816 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1817 * users to use other limit switch sensors connected to
1818 * robot controller. This also allows use of active
1819 * sensors that require external power.
1820 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1821 * the LimitForwardMotion and LimitReverseMotion
1822 * parameters, instead allowing motion.
1823 *
1824 * This can be useful on mechanisms such as an
1825 * intake/feeder, where a limit switch stops motion
1826 * while intaking but should be ignored when feeding
1827 * to a shooter.
1828 *
1829 * The hardware limit faults and Forward/ReverseLimit
1830 * signals will still report the values of the limit
1831 * switches regardless of this parameter.
1832 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1833 * allowing motion.
1834 *
1835 * This can be useful when calibrating the zero point
1836 * of a mechanism such as an elevator.
1837 *
1838 * The software limit faults will still report the
1839 * values of the software limits regardless of this
1840 * parameter.
1841 * - UseTimesync: Set to true to delay applying this control request until a
1842 * timesync boundary (requires Phoenix Pro and CANivore). This
1843 * eliminates the impact of nondeterministic network delays in
1844 * exchange for a larger but deterministic control latency.
1845 *
1846 * This requires setting the ControlTimesyncFreqHz config in
1847 * MotorOutputConfigs. Additionally, when this is enabled, the
1848 * UpdateFreqHz of this request should be set to 0 Hz.
1849 *
1850 * \param request Control object to request of the device
1851 * \returns Status Code of the request, 0 is OK
1852 */
1853 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialPositionVoltage &request) = 0;
1854
1855 /**
1856 * \brief Request PID to target velocity with a differential position
1857 * setpoint.
1858 *
1859 * \details This control mode will set the motor's velocity setpoint
1860 * to the velocity specified by the user. It will also set the motor's
1861 * differential position setpoint to the specified position.
1862 *
1863 * - DifferentialVelocityDutyCycle Parameters:
1864 * - AverageVelocity: Average velocity to drive toward in rotations per
1865 * second.
1866 * - DifferentialPosition: Differential position to drive toward in rotations.
1867 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1868 * which increases peak power by ~15% on supported devices (see
1869 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1870 * commutation.
1871 *
1872 * FOC improves motor performance by leveraging torque (current)
1873 * control. However, this may be inconvenient for applications
1874 * that require specifying duty cycle or voltage.
1875 * CTR-Electronics has developed a hybrid method that combines
1876 * the performances gains of FOC while still allowing
1877 * applications to provide duty cycle or voltage demand. This
1878 * not to be confused with simple sinusoidal control or phase
1879 * voltage control which lacks the performance gains.
1880 * - AverageSlot: Select which gains are applied to the average controller by
1881 * selecting the slot. Use the configuration api to set the
1882 * gain values for the selected slot before enabling this
1883 * feature. Slot must be within [0,2].
1884 * - DifferentialSlot: Select which gains are applied to the differential
1885 * controller by selecting the slot. Use the
1886 * configuration api to set the gain values for the
1887 * selected slot before enabling this feature. Slot must
1888 * be within [0,2].
1889 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1890 * output is zero (or within deadband). Set to
1891 * false to use the NeutralMode configuration
1892 * setting (default). This flag exists to provide
1893 * the fundamental behavior of this control when
1894 * output is zero, which is to provide 0V to the
1895 * motor.
1896 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1897 * users to use other limit switch sensors connected to
1898 * robot controller. This also allows use of active
1899 * sensors that require external power.
1900 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1901 * users to use other limit switch sensors connected to
1902 * robot controller. This also allows use of active
1903 * sensors that require external power.
1904 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1905 * the LimitForwardMotion and LimitReverseMotion
1906 * parameters, instead allowing motion.
1907 *
1908 * This can be useful on mechanisms such as an
1909 * intake/feeder, where a limit switch stops motion
1910 * while intaking but should be ignored when feeding
1911 * to a shooter.
1912 *
1913 * The hardware limit faults and Forward/ReverseLimit
1914 * signals will still report the values of the limit
1915 * switches regardless of this parameter.
1916 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
1917 * allowing motion.
1918 *
1919 * This can be useful when calibrating the zero point
1920 * of a mechanism such as an elevator.
1921 *
1922 * The software limit faults will still report the
1923 * values of the software limits regardless of this
1924 * parameter.
1925 * - UseTimesync: Set to true to delay applying this control request until a
1926 * timesync boundary (requires Phoenix Pro and CANivore). This
1927 * eliminates the impact of nondeterministic network delays in
1928 * exchange for a larger but deterministic control latency.
1929 *
1930 * This requires setting the ControlTimesyncFreqHz config in
1931 * MotorOutputConfigs. Additionally, when this is enabled, the
1932 * UpdateFreqHz of this request should be set to 0 Hz.
1933 *
1934 * \param request Control object to request of the device
1935 * \returns Status Code of the request, 0 is OK
1936 */
1937 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVelocityDutyCycle &request) = 0;
1938
1939 /**
1940 * \brief Request PID to target velocity with a differential position
1941 * setpoint.
1942 *
1943 * \details This control mode will set the motor's velocity setpoint
1944 * to the velocity specified by the user. It will also set the motor's
1945 * differential position setpoint to the specified position.
1946 *
1947 * - DifferentialVelocityVoltage Parameters:
1948 * - AverageVelocity: Average velocity to drive toward in rotations per
1949 * second.
1950 * - DifferentialPosition: Differential position to drive toward in rotations.
1951 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
1952 * which increases peak power by ~15% on supported devices (see
1953 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
1954 * commutation.
1955 *
1956 * FOC improves motor performance by leveraging torque (current)
1957 * control. However, this may be inconvenient for applications
1958 * that require specifying duty cycle or voltage.
1959 * CTR-Electronics has developed a hybrid method that combines
1960 * the performances gains of FOC while still allowing
1961 * applications to provide duty cycle or voltage demand. This
1962 * not to be confused with simple sinusoidal control or phase
1963 * voltage control which lacks the performance gains.
1964 * - AverageSlot: Select which gains are applied to the average controller by
1965 * selecting the slot. Use the configuration api to set the
1966 * gain values for the selected slot before enabling this
1967 * feature. Slot must be within [0,2].
1968 * - DifferentialSlot: Select which gains are applied to the differential
1969 * controller by selecting the slot. Use the
1970 * configuration api to set the gain values for the
1971 * selected slot before enabling this feature. Slot must
1972 * be within [0,2].
1973 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
1974 * output is zero (or within deadband). Set to
1975 * false to use the NeutralMode configuration
1976 * setting (default). This flag exists to provide
1977 * the fundamental behavior of this control when
1978 * output is zero, which is to provide 0V to the
1979 * motor.
1980 * - LimitForwardMotion: Set to true to force forward limiting. This allows
1981 * users to use other limit switch sensors connected to
1982 * robot controller. This also allows use of active
1983 * sensors that require external power.
1984 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
1985 * users to use other limit switch sensors connected to
1986 * robot controller. This also allows use of active
1987 * sensors that require external power.
1988 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
1989 * the LimitForwardMotion and LimitReverseMotion
1990 * parameters, instead allowing motion.
1991 *
1992 * This can be useful on mechanisms such as an
1993 * intake/feeder, where a limit switch stops motion
1994 * while intaking but should be ignored when feeding
1995 * to a shooter.
1996 *
1997 * The hardware limit faults and Forward/ReverseLimit
1998 * signals will still report the values of the limit
1999 * switches regardless of this parameter.
2000 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2001 * allowing motion.
2002 *
2003 * This can be useful when calibrating the zero point
2004 * of a mechanism such as an elevator.
2005 *
2006 * The software limit faults will still report the
2007 * values of the software limits regardless of this
2008 * parameter.
2009 * - UseTimesync: Set to true to delay applying this control request until a
2010 * timesync boundary (requires Phoenix Pro and CANivore). This
2011 * eliminates the impact of nondeterministic network delays in
2012 * exchange for a larger but deterministic control latency.
2013 *
2014 * This requires setting the ControlTimesyncFreqHz config in
2015 * MotorOutputConfigs. Additionally, when this is enabled, the
2016 * UpdateFreqHz of this request should be set to 0 Hz.
2017 *
2018 * \param request Control object to request of the device
2019 * \returns Status Code of the request, 0 is OK
2020 */
2021 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVelocityVoltage &request) = 0;
2022
2023 /**
2024 * \brief Requests Motion Magic® to target a final position using a
2025 * motion profile, and PID to a differential position setpoint.
2026 *
2027 * \details Motion Magic® produces a motion profile in real-time while
2028 * attempting to honor the Cruise Velocity, Acceleration, and
2029 * (optional) Jerk specified via the Motion Magic® configuration
2030 * values. This control mode does not use the Expo_kV or Expo_kA
2031 * configs.
2032 *
2033 * Target position can be changed on-the-fly and Motion Magic® will do
2034 * its best to adjust the profile. This control mode is duty cycle
2035 * based, so relevant closed-loop gains will use fractional duty cycle
2036 * for the numerator: +1.0 represents full forward output.
2037 *
2038 * - DifferentialMotionMagicDutyCycle Parameters:
2039 * - AveragePosition: Average position to drive toward in rotations.
2040 * - DifferentialPosition: Differential position to drive toward in rotations.
2041 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2042 * which increases peak power by ~15% on supported devices (see
2043 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2044 * commutation.
2045 *
2046 * FOC improves motor performance by leveraging torque (current)
2047 * control. However, this may be inconvenient for applications
2048 * that require specifying duty cycle or voltage.
2049 * CTR-Electronics has developed a hybrid method that combines
2050 * the performances gains of FOC while still allowing
2051 * applications to provide duty cycle or voltage demand. This
2052 * not to be confused with simple sinusoidal control or phase
2053 * voltage control which lacks the performance gains.
2054 * - AverageSlot: Select which gains are applied to the average controller by
2055 * selecting the slot. Use the configuration api to set the
2056 * gain values for the selected slot before enabling this
2057 * feature. Slot must be within [0,2].
2058 * - DifferentialSlot: Select which gains are applied to the differential
2059 * controller by selecting the slot. Use the
2060 * configuration api to set the gain values for the
2061 * selected slot before enabling this feature. Slot must
2062 * be within [0,2].
2063 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2064 * output is zero (or within deadband). Set to
2065 * false to use the NeutralMode configuration
2066 * setting (default). This flag exists to provide
2067 * the fundamental behavior of this control when
2068 * output is zero, which is to provide 0V to the
2069 * motor.
2070 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2071 * users to use other limit switch sensors connected to
2072 * robot controller. This also allows use of active
2073 * sensors that require external power.
2074 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2075 * users to use other limit switch sensors connected to
2076 * robot controller. This also allows use of active
2077 * sensors that require external power.
2078 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2079 * the LimitForwardMotion and LimitReverseMotion
2080 * parameters, instead allowing motion.
2081 *
2082 * This can be useful on mechanisms such as an
2083 * intake/feeder, where a limit switch stops motion
2084 * while intaking but should be ignored when feeding
2085 * to a shooter.
2086 *
2087 * The hardware limit faults and Forward/ReverseLimit
2088 * signals will still report the values of the limit
2089 * switches regardless of this parameter.
2090 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2091 * allowing motion.
2092 *
2093 * This can be useful when calibrating the zero point
2094 * of a mechanism such as an elevator.
2095 *
2096 * The software limit faults will still report the
2097 * values of the software limits regardless of this
2098 * parameter.
2099 * - UseTimesync: Set to true to delay applying this control request until a
2100 * timesync boundary (requires Phoenix Pro and CANivore). This
2101 * eliminates the impact of nondeterministic network delays in
2102 * exchange for a larger but deterministic control latency.
2103 *
2104 * This requires setting the ControlTimesyncFreqHz config in
2105 * MotorOutputConfigs. Additionally, when this is enabled, the
2106 * UpdateFreqHz of this request should be set to 0 Hz.
2107 *
2108 * \param request Control object to request of the device
2109 * \returns Status Code of the request, 0 is OK
2110 */
2111 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicDutyCycle &request) = 0;
2112
2113 /**
2114 * \brief Requests Motion Magic® to target a final position using a
2115 * motion profile, and PID to a differential position setpoint.
2116 *
2117 * \details Motion Magic® produces a motion profile in real-time while
2118 * attempting to honor the Cruise Velocity, Acceleration, and
2119 * (optional) Jerk specified via the Motion Magic® configuration
2120 * values. This control mode does not use the Expo_kV or Expo_kA
2121 * configs.
2122 *
2123 * Target position can be changed on-the-fly and Motion Magic® will do
2124 * its best to adjust the profile. This control mode is
2125 * voltage-based, so relevant closed-loop gains will use Volts for the
2126 * numerator.
2127 *
2128 * - DifferentialMotionMagicVoltage Parameters:
2129 * - AveragePosition: Average position to drive toward in rotations.
2130 * - DifferentialPosition: Differential position to drive toward in rotations.
2131 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2132 * which increases peak power by ~15% on supported devices (see
2133 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2134 * commutation.
2135 *
2136 * FOC improves motor performance by leveraging torque (current)
2137 * control. However, this may be inconvenient for applications
2138 * that require specifying duty cycle or voltage.
2139 * CTR-Electronics has developed a hybrid method that combines
2140 * the performances gains of FOC while still allowing
2141 * applications to provide duty cycle or voltage demand. This
2142 * not to be confused with simple sinusoidal control or phase
2143 * voltage control which lacks the performance gains.
2144 * - AverageSlot: Select which gains are applied to the average controller by
2145 * selecting the slot. Use the configuration api to set the
2146 * gain values for the selected slot before enabling this
2147 * feature. Slot must be within [0,2].
2148 * - DifferentialSlot: Select which gains are applied to the differential
2149 * controller by selecting the slot. Use the
2150 * configuration api to set the gain values for the
2151 * selected slot before enabling this feature. Slot must
2152 * be within [0,2].
2153 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2154 * output is zero (or within deadband). Set to
2155 * false to use the NeutralMode configuration
2156 * setting (default). This flag exists to provide
2157 * the fundamental behavior of this control when
2158 * output is zero, which is to provide 0V to the
2159 * motor.
2160 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2161 * users to use other limit switch sensors connected to
2162 * robot controller. This also allows use of active
2163 * sensors that require external power.
2164 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2165 * users to use other limit switch sensors connected to
2166 * robot controller. This also allows use of active
2167 * sensors that require external power.
2168 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2169 * the LimitForwardMotion and LimitReverseMotion
2170 * parameters, instead allowing motion.
2171 *
2172 * This can be useful on mechanisms such as an
2173 * intake/feeder, where a limit switch stops motion
2174 * while intaking but should be ignored when feeding
2175 * to a shooter.
2176 *
2177 * The hardware limit faults and Forward/ReverseLimit
2178 * signals will still report the values of the limit
2179 * switches regardless of this parameter.
2180 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2181 * allowing motion.
2182 *
2183 * This can be useful when calibrating the zero point
2184 * of a mechanism such as an elevator.
2185 *
2186 * The software limit faults will still report the
2187 * values of the software limits regardless of this
2188 * parameter.
2189 * - UseTimesync: Set to true to delay applying this control request until a
2190 * timesync boundary (requires Phoenix Pro and CANivore). This
2191 * eliminates the impact of nondeterministic network delays in
2192 * exchange for a larger but deterministic control latency.
2193 *
2194 * This requires setting the ControlTimesyncFreqHz config in
2195 * MotorOutputConfigs. Additionally, when this is enabled, the
2196 * UpdateFreqHz of this request should be set to 0 Hz.
2197 *
2198 * \param request Control object to request of the device
2199 * \returns Status Code of the request, 0 is OK
2200 */
2201 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVoltage &request) = 0;
2202
2203 /**
2204 * \brief Requests Motion Magic® to target a final position using an
2205 * exponential motion profile, and PID to a differential position
2206 * setpoint.
2207 *
2208 * \details Motion Magic® Expo produces a motion profile in real-time
2209 * while attempting to honor the Cruise Velocity (optional) and the
2210 * mechanism kV and kA, specified via the Motion Magic® configuration
2211 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
2212 * configs are always in output units of Volts.
2213 *
2214 * Setting Cruise Velocity to 0 will allow the profile to run to the
2215 * max possible velocity based on Expo_kV. This control mode does not
2216 * use the Acceleration or Jerk configs.
2217 *
2218 * Target position can be changed on-the-fly and Motion Magic® will do
2219 * its best to adjust the profile. This control mode is duty cycle
2220 * based, so relevant closed-loop gains will use fractional duty cycle
2221 * for the numerator: +1.0 represents full forward output.
2222 *
2223 * - DifferentialMotionMagicExpoDutyCycle Parameters:
2224 * - AveragePosition: Average position to drive toward in rotations.
2225 * - DifferentialPosition: Differential position to drive toward in rotations.
2226 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2227 * which increases peak power by ~15% on supported devices (see
2228 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2229 * commutation.
2230 *
2231 * FOC improves motor performance by leveraging torque (current)
2232 * control. However, this may be inconvenient for applications
2233 * that require specifying duty cycle or voltage.
2234 * CTR-Electronics has developed a hybrid method that combines
2235 * the performances gains of FOC while still allowing
2236 * applications to provide duty cycle or voltage demand. This
2237 * not to be confused with simple sinusoidal control or phase
2238 * voltage control which lacks the performance gains.
2239 * - AverageSlot: Select which gains are applied to the average controller by
2240 * selecting the slot. Use the configuration api to set the
2241 * gain values for the selected slot before enabling this
2242 * feature. Slot must be within [0,2].
2243 * - DifferentialSlot: Select which gains are applied to the differential
2244 * controller by selecting the slot. Use the
2245 * configuration api to set the gain values for the
2246 * selected slot before enabling this feature. Slot must
2247 * be within [0,2].
2248 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2249 * output is zero (or within deadband). Set to
2250 * false to use the NeutralMode configuration
2251 * setting (default). This flag exists to provide
2252 * the fundamental behavior of this control when
2253 * output is zero, which is to provide 0V to the
2254 * motor.
2255 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2256 * users to use other limit switch sensors connected to
2257 * robot controller. This also allows use of active
2258 * sensors that require external power.
2259 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2260 * users to use other limit switch sensors connected to
2261 * robot controller. This also allows use of active
2262 * sensors that require external power.
2263 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2264 * the LimitForwardMotion and LimitReverseMotion
2265 * parameters, instead allowing motion.
2266 *
2267 * This can be useful on mechanisms such as an
2268 * intake/feeder, where a limit switch stops motion
2269 * while intaking but should be ignored when feeding
2270 * to a shooter.
2271 *
2272 * The hardware limit faults and Forward/ReverseLimit
2273 * signals will still report the values of the limit
2274 * switches regardless of this parameter.
2275 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2276 * allowing motion.
2277 *
2278 * This can be useful when calibrating the zero point
2279 * of a mechanism such as an elevator.
2280 *
2281 * The software limit faults will still report the
2282 * values of the software limits regardless of this
2283 * parameter.
2284 * - UseTimesync: Set to true to delay applying this control request until a
2285 * timesync boundary (requires Phoenix Pro and CANivore). This
2286 * eliminates the impact of nondeterministic network delays in
2287 * exchange for a larger but deterministic control latency.
2288 *
2289 * This requires setting the ControlTimesyncFreqHz config in
2290 * MotorOutputConfigs. Additionally, when this is enabled, the
2291 * UpdateFreqHz of this request should be set to 0 Hz.
2292 *
2293 * \param request Control object to request of the device
2294 * \returns Status Code of the request, 0 is OK
2295 */
2296 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicExpoDutyCycle &request) = 0;
2297
2298 /**
2299 * \brief Requests Motion Magic® to target a final position using an
2300 * exponential motion profile, and PID to a differential position
2301 * setpoint.
2302 *
2303 * \details Motion Magic® Expo produces a motion profile in real-time
2304 * while attempting to honor the Cruise Velocity (optional) and the
2305 * mechanism kV and kA, specified via the Motion Magic® configuration
2306 * values. Note that unlike the slot gains, the Expo_kV and Expo_kA
2307 * configs are always in output units of Volts.
2308 *
2309 * Setting Cruise Velocity to 0 will allow the profile to run to the
2310 * max possible velocity based on Expo_kV. This control mode does not
2311 * use the Acceleration or Jerk configs.
2312 *
2313 * Target position can be changed on-the-fly and Motion Magic® will do
2314 * its best to adjust the profile. This control mode is
2315 * voltage-based, so relevant closed-loop gains will use Volts for the
2316 * numerator.
2317 *
2318 * - DifferentialMotionMagicExpoVoltage Parameters:
2319 * - AveragePosition: Average position to drive toward in rotations.
2320 * - DifferentialPosition: Differential position to drive toward in rotations.
2321 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2322 * which increases peak power by ~15% on supported devices (see
2323 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2324 * commutation.
2325 *
2326 * FOC improves motor performance by leveraging torque (current)
2327 * control. However, this may be inconvenient for applications
2328 * that require specifying duty cycle or voltage.
2329 * CTR-Electronics has developed a hybrid method that combines
2330 * the performances gains of FOC while still allowing
2331 * applications to provide duty cycle or voltage demand. This
2332 * not to be confused with simple sinusoidal control or phase
2333 * voltage control which lacks the performance gains.
2334 * - AverageSlot: Select which gains are applied to the average controller by
2335 * selecting the slot. Use the configuration api to set the
2336 * gain values for the selected slot before enabling this
2337 * feature. Slot must be within [0,2].
2338 * - DifferentialSlot: Select which gains are applied to the differential
2339 * controller by selecting the slot. Use the
2340 * configuration api to set the gain values for the
2341 * selected slot before enabling this feature. Slot must
2342 * be within [0,2].
2343 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2344 * output is zero (or within deadband). Set to
2345 * false to use the NeutralMode configuration
2346 * setting (default). This flag exists to provide
2347 * the fundamental behavior of this control when
2348 * output is zero, which is to provide 0V to the
2349 * motor.
2350 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2351 * users to use other limit switch sensors connected to
2352 * robot controller. This also allows use of active
2353 * sensors that require external power.
2354 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2355 * users to use other limit switch sensors connected to
2356 * robot controller. This also allows use of active
2357 * sensors that require external power.
2358 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2359 * the LimitForwardMotion and LimitReverseMotion
2360 * parameters, instead allowing motion.
2361 *
2362 * This can be useful on mechanisms such as an
2363 * intake/feeder, where a limit switch stops motion
2364 * while intaking but should be ignored when feeding
2365 * to a shooter.
2366 *
2367 * The hardware limit faults and Forward/ReverseLimit
2368 * signals will still report the values of the limit
2369 * switches regardless of this parameter.
2370 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2371 * allowing motion.
2372 *
2373 * This can be useful when calibrating the zero point
2374 * of a mechanism such as an elevator.
2375 *
2376 * The software limit faults will still report the
2377 * values of the software limits regardless of this
2378 * parameter.
2379 * - UseTimesync: Set to true to delay applying this control request until a
2380 * timesync boundary (requires Phoenix Pro and CANivore). This
2381 * eliminates the impact of nondeterministic network delays in
2382 * exchange for a larger but deterministic control latency.
2383 *
2384 * This requires setting the ControlTimesyncFreqHz config in
2385 * MotorOutputConfigs. Additionally, when this is enabled, the
2386 * UpdateFreqHz of this request should be set to 0 Hz.
2387 *
2388 * \param request Control object to request of the device
2389 * \returns Status Code of the request, 0 is OK
2390 */
2391 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicExpoVoltage &request) = 0;
2392
2393 /**
2394 * \brief Requests Motion Magic® to target a final velocity using a
2395 * motion profile, and PID to a differential position setpoint. This
2396 * allows smooth transitions between velocity set points.
2397 *
2398 * \details Motion Magic® Velocity produces a motion profile in
2399 * real-time while attempting to honor the specified Acceleration and
2400 * (optional) Jerk. This control mode does not use the
2401 * CruiseVelocity, Expo_kV, or Expo_kA configs.
2402 *
2403 * Acceleration and jerk are specified in the Motion Magic® persistent
2404 * configuration values. If Jerk is set to zero, Motion Magic® will
2405 * produce a trapezoidal acceleration profile.
2406 *
2407 * Target velocity can also be changed on-the-fly and Motion Magic®
2408 * will do its best to adjust the profile. This control mode is duty
2409 * cycle based, so relevant closed-loop gains will use fractional duty
2410 * cycle for the numerator: +1.0 represents full forward output.
2411 *
2412 * - DifferentialMotionMagicVelocityDutyCycle Parameters:
2413 * - AverageVelocity: Average velocity to drive toward in rotations per
2414 * second.
2415 * - DifferentialPosition: Differential position to drive toward in rotations.
2416 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2417 * which increases peak power by ~15% on supported devices (see
2418 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2419 * commutation.
2420 *
2421 * FOC improves motor performance by leveraging torque (current)
2422 * control. However, this may be inconvenient for applications
2423 * that require specifying duty cycle or voltage.
2424 * CTR-Electronics has developed a hybrid method that combines
2425 * the performances gains of FOC while still allowing
2426 * applications to provide duty cycle or voltage demand. This
2427 * not to be confused with simple sinusoidal control or phase
2428 * voltage control which lacks the performance gains.
2429 * - AverageSlot: Select which gains are applied to the average controller by
2430 * selecting the slot. Use the configuration api to set the
2431 * gain values for the selected slot before enabling this
2432 * feature. Slot must be within [0,2].
2433 * - DifferentialSlot: Select which gains are applied to the differential
2434 * controller by selecting the slot. Use the
2435 * configuration api to set the gain values for the
2436 * selected slot before enabling this feature. Slot must
2437 * be within [0,2].
2438 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2439 * output is zero (or within deadband). Set to
2440 * false to use the NeutralMode configuration
2441 * setting (default). This flag exists to provide
2442 * the fundamental behavior of this control when
2443 * output is zero, which is to provide 0V to the
2444 * motor.
2445 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2446 * users to use other limit switch sensors connected to
2447 * robot controller. This also allows use of active
2448 * sensors that require external power.
2449 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2450 * users to use other limit switch sensors connected to
2451 * robot controller. This also allows use of active
2452 * sensors that require external power.
2453 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2454 * the LimitForwardMotion and LimitReverseMotion
2455 * parameters, instead allowing motion.
2456 *
2457 * This can be useful on mechanisms such as an
2458 * intake/feeder, where a limit switch stops motion
2459 * while intaking but should be ignored when feeding
2460 * to a shooter.
2461 *
2462 * The hardware limit faults and Forward/ReverseLimit
2463 * signals will still report the values of the limit
2464 * switches regardless of this parameter.
2465 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2466 * allowing motion.
2467 *
2468 * This can be useful when calibrating the zero point
2469 * of a mechanism such as an elevator.
2470 *
2471 * The software limit faults will still report the
2472 * values of the software limits regardless of this
2473 * parameter.
2474 * - UseTimesync: Set to true to delay applying this control request until a
2475 * timesync boundary (requires Phoenix Pro and CANivore). This
2476 * eliminates the impact of nondeterministic network delays in
2477 * exchange for a larger but deterministic control latency.
2478 *
2479 * This requires setting the ControlTimesyncFreqHz config in
2480 * MotorOutputConfigs. Additionally, when this is enabled, the
2481 * UpdateFreqHz of this request should be set to 0 Hz.
2482 *
2483 * \param request Control object to request of the device
2484 * \returns Status Code of the request, 0 is OK
2485 */
2486 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVelocityDutyCycle &request) = 0;
2487
2488 /**
2489 * \brief Requests Motion Magic® to target a final velocity using a
2490 * motion profile, and PID to a differential position setpoint. This
2491 * allows smooth transitions between velocity set points.
2492 *
2493 * \details Motion Magic® Velocity produces a motion profile in
2494 * real-time while attempting to honor the specified Acceleration and
2495 * (optional) Jerk. This control mode does not use the
2496 * CruiseVelocity, Expo_kV, or Expo_kA configs.
2497 *
2498 * Acceleration and jerk are specified in the Motion Magic® persistent
2499 * configuration values. If Jerk is set to zero, Motion Magic® will
2500 * produce a trapezoidal acceleration profile.
2501 *
2502 * Target velocity can also be changed on-the-fly and Motion Magic®
2503 * will do its best to adjust the profile. This control mode is
2504 * voltage-based, so relevant closed-loop gains will use Volts for the
2505 * numerator.
2506 *
2507 * - DifferentialMotionMagicVelocityVoltage Parameters:
2508 * - AverageVelocity: Average velocity to drive toward in rotations per
2509 * second.
2510 * - DifferentialPosition: Differential position to drive toward in rotations.
2511 * - EnableFOC: Set to true to use FOC commutation (requires Phoenix Pro),
2512 * which increases peak power by ~15% on supported devices (see
2513 * hardware#traits#SupportsFOC). Set to false to use trapezoidal
2514 * commutation.
2515 *
2516 * FOC improves motor performance by leveraging torque (current)
2517 * control. However, this may be inconvenient for applications
2518 * that require specifying duty cycle or voltage.
2519 * CTR-Electronics has developed a hybrid method that combines
2520 * the performances gains of FOC while still allowing
2521 * applications to provide duty cycle or voltage demand. This
2522 * not to be confused with simple sinusoidal control or phase
2523 * voltage control which lacks the performance gains.
2524 * - AverageSlot: Select which gains are applied to the average controller by
2525 * selecting the slot. Use the configuration api to set the
2526 * gain values for the selected slot before enabling this
2527 * feature. Slot must be within [0,2].
2528 * - DifferentialSlot: Select which gains are applied to the differential
2529 * controller by selecting the slot. Use the
2530 * configuration api to set the gain values for the
2531 * selected slot before enabling this feature. Slot must
2532 * be within [0,2].
2533 * - OverrideBrakeDurNeutral: Set to true to static-brake the rotor when
2534 * output is zero (or within deadband). Set to
2535 * false to use the NeutralMode configuration
2536 * setting (default). This flag exists to provide
2537 * the fundamental behavior of this control when
2538 * output is zero, which is to provide 0V to the
2539 * motor.
2540 * - LimitForwardMotion: Set to true to force forward limiting. This allows
2541 * users to use other limit switch sensors connected to
2542 * robot controller. This also allows use of active
2543 * sensors that require external power.
2544 * - LimitReverseMotion: Set to true to force reverse limiting. This allows
2545 * users to use other limit switch sensors connected to
2546 * robot controller. This also allows use of active
2547 * sensors that require external power.
2548 * - IgnoreHardwareLimits: Set to true to ignore hardware limit switches and
2549 * the LimitForwardMotion and LimitReverseMotion
2550 * parameters, instead allowing motion.
2551 *
2552 * This can be useful on mechanisms such as an
2553 * intake/feeder, where a limit switch stops motion
2554 * while intaking but should be ignored when feeding
2555 * to a shooter.
2556 *
2557 * The hardware limit faults and Forward/ReverseLimit
2558 * signals will still report the values of the limit
2559 * switches regardless of this parameter.
2560 * - IgnoreSoftwareLimits: Set to true to ignore software limits, instead
2561 * allowing motion.
2562 *
2563 * This can be useful when calibrating the zero point
2564 * of a mechanism such as an elevator.
2565 *
2566 * The software limit faults will still report the
2567 * values of the software limits regardless of this
2568 * parameter.
2569 * - UseTimesync: Set to true to delay applying this control request until a
2570 * timesync boundary (requires Phoenix Pro and CANivore). This
2571 * eliminates the impact of nondeterministic network delays in
2572 * exchange for a larger but deterministic control latency.
2573 *
2574 * This requires setting the ControlTimesyncFreqHz config in
2575 * MotorOutputConfigs. Additionally, when this is enabled, the
2576 * UpdateFreqHz of this request should be set to 0 Hz.
2577 *
2578 * \param request Control object to request of the device
2579 * \returns Status Code of the request, 0 is OK
2580 */
2581 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVelocityVoltage &request) = 0;
2582
2583 /**
2584 * \brief Follow the motor output of another Talon.
2585 *
2586 * \details If Talon is in torque control, the torque is copied -
2587 * which will increase the total torque applied. If Talon is in duty
2588 * cycle output control, the duty cycle is matched. If Talon is in
2589 * voltage output control, the motor voltage is matched. Motor
2590 * direction either matches the leader's configured direction or
2591 * opposes it based on the MotorAlignment.
2592 *
2593 * The leader must enable the status signal corresponding to its
2594 * control output type (DutyCycle, MotorVoltage, TorqueCurrent). The
2595 * update rate of the status signal determines the update rate of the
2596 * follower's output and should be no slower than 20 Hz.
2597 *
2598 * - Follower Parameters:
2599 * - LeaderID: Device ID of the leader to follow.
2600 * - MotorAlignment: Set to Aligned for motor invert to match the leader's
2601 * configured Invert - which is typical when leader and
2602 * follower are mechanically linked and spin in the same
2603 * direction. Set to Opposed for motor invert to oppose the
2604 * leader's configured Invert - this is typical where the
2605 * leader and follower mechanically spin in opposite
2606 * directions.
2607 *
2608 * \param request Control object to request of the device
2609 * \returns Status Code of the request, 0 is OK
2610 */
2611 virtual ctre::phoenix::StatusCode SetControl(const controls::Follower &request) = 0;
2612
2613 /**
2614 * \brief Follow the motor output of another Talon while ignoring the
2615 * leader's invert setting.
2616 *
2617 * \details If Talon is in torque control, the torque is copied -
2618 * which will increase the total torque applied. If Talon is in duty
2619 * cycle output control, the duty cycle is matched. If Talon is in
2620 * voltage output control, the motor voltage is matched. Motor
2621 * direction is strictly determined by the configured invert and not
2622 * the leader. If you want motor direction to match or oppose the
2623 * leader, use Follower instead.
2624 *
2625 * The leader must enable the status signal corresponding to its
2626 * control output type (DutyCycle, MotorVoltage, TorqueCurrent). The
2627 * update rate of the status signal determines the update rate of the
2628 * follower's output and should be no slower than 20 Hz.
2629 *
2630 * - StrictFollower Parameters:
2631 * - LeaderID: Device ID of the leader to follow.
2632 *
2633 * \param request Control object to request of the device
2634 * \returns Status Code of the request, 0 is OK
2635 */
2636 virtual ctre::phoenix::StatusCode SetControl(const controls::StrictFollower &request) = 0;
2637
2638 /**
2639 * \brief Follow the differential motor output of another Talon.
2640 *
2641 * \details If Talon is in torque control, the differential torque is
2642 * copied - which will increase the total torque applied. If Talon is
2643 * in duty cycle output control, the differential duty cycle is
2644 * matched. If Talon is in voltage output control, the differential
2645 * motor voltage is matched. Motor direction either matches leader's
2646 * configured direction or opposes it based on the MotorAlignment.
2647 *
2648 * The leader must enable its DifferentialOutput status signal. The
2649 * update rate of the status signal determines the update rate of the
2650 * follower's output and should be no slower than 20 Hz.
2651 *
2652 * - DifferentialFollower Parameters:
2653 * - LeaderID: Device ID of the differential leader to follow.
2654 * - MotorAlignment: Set to Aligned for motor invert to match the leader's
2655 * configured Invert - which is typical when leader and
2656 * follower are mechanically linked and spin in the same
2657 * direction. Set to Opposed for motor invert to oppose the
2658 * leader's configured Invert - this is typical where the
2659 * leader and follower mechanically spin in opposite
2660 * directions.
2661 *
2662 * \param request Control object to request of the device
2663 * \returns Status Code of the request, 0 is OK
2664 */
2665 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialFollower &request) = 0;
2666
2667 /**
2668 * \brief Follow the differential motor output of another Talon while
2669 * ignoring the leader's invert setting.
2670 *
2671 * \details If Talon is in torque control, the differential torque is
2672 * copied - which will increase the total torque applied. If Talon is
2673 * in duty cycle output control, the differential duty cycle is
2674 * matched. If Talon is in voltage output control, the differential
2675 * motor voltage is matched. Motor direction is strictly determined by
2676 * the configured invert and not the leader. If you want motor
2677 * direction to match or oppose the leader, use DifferentialFollower
2678 * instead.
2679 *
2680 * The leader must enable its DifferentialOutput status signal. The
2681 * update rate of the status signal determines the update rate of the
2682 * follower's output and should be no slower than 20 Hz.
2683 *
2684 * - DifferentialStrictFollower Parameters:
2685 * - LeaderID: Device ID of the differential leader to follow.
2686 *
2687 * \param request Control object to request of the device
2688 * \returns Status Code of the request, 0 is OK
2689 */
2690 virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialStrictFollower &request) = 0;
2691
2692 /**
2693 * \brief Applies full neutral-brake by shorting motor leads together.
2694 *
2695 * - StaticBrake Parameters:
2696 * - UseTimesync: Set to true to delay applying this control request until a
2697 * timesync boundary (requires Phoenix Pro and CANivore). This
2698 * eliminates the impact of nondeterministic network delays in
2699 * exchange for a larger but deterministic control latency.
2700 *
2701 * This requires setting the ControlTimesyncFreqHz config in
2702 * MotorOutputConfigs. Additionally, when this is enabled, the
2703 * UpdateFreqHz of this request should be set to 0 Hz.
2704 *
2705 * \param request Control object to request of the device
2706 * \returns Status Code of the request, 0 is OK
2707 */
2708 virtual ctre::phoenix::StatusCode SetControl(const controls::StaticBrake &request) = 0;
2709
2710 /**
2711 * \brief Request neutral output of actuator. The applied brake type
2712 * is determined by the NeutralMode configuration.
2713 *
2714 * - NeutralOut Parameters:
2715 * - UseTimesync: Set to true to delay applying this control request until a
2716 * timesync boundary (requires Phoenix Pro and CANivore). This
2717 * eliminates the impact of nondeterministic network delays in
2718 * exchange for a larger but deterministic control latency.
2719 *
2720 * This requires setting the ControlTimesyncFreqHz config in
2721 * MotorOutputConfigs. Additionally, when this is enabled, the
2722 * UpdateFreqHz of this request should be set to 0 Hz.
2723 *
2724 * \param request Control object to request of the device
2725 * \returns Status Code of the request, 0 is OK
2726 */
2727 virtual ctre::phoenix::StatusCode SetControl(const controls::NeutralOut &request) = 0;
2728
2729 /**
2730 * \brief Request coast neutral output of actuator. The bridge is
2731 * disabled and the rotor is allowed to coast.
2732 *
2733 * - CoastOut Parameters:
2734 * - UseTimesync: Set to true to delay applying this control request until a
2735 * timesync boundary (requires Phoenix Pro and CANivore). This
2736 * eliminates the impact of nondeterministic network delays in
2737 * exchange for a larger but deterministic control latency.
2738 *
2739 * This requires setting the ControlTimesyncFreqHz config in
2740 * MotorOutputConfigs. Additionally, when this is enabled, the
2741 * UpdateFreqHz of this request should be set to 0 Hz.
2742 *
2743 * \param request Control object to request of the device
2744 * \returns Status Code of the request, 0 is OK
2745 */
2746 virtual ctre::phoenix::StatusCode SetControl(const controls::CoastOut &request) = 0;
2747
2748 /**
2749 * \brief Differential control with duty cycle average target and
2750 * position difference target.
2751 *
2752 * - Diff_DutyCycleOut_Position Parameters:
2753 * - AverageRequest: Average DutyCycleOut request of the mechanism.
2754 * - DifferentialRequest: Differential PositionDutyCycle request of the
2755 * mechanism.
2756 *
2757 * \param request Control object to request of the device
2758 * \returns Status Code of the request, 0 is OK
2759 */
2760 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Position &request) = 0;
2761
2762 /**
2763 * \brief Differential control with position average target and
2764 * position difference target using duty cycle control.
2765 *
2766 * - Diff_PositionDutyCycle_Position Parameters:
2767 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
2768 * - DifferentialRequest: Differential PositionDutyCycle request of the
2769 * mechanism.
2770 *
2771 * \param request Control object to request of the device
2772 * \returns Status Code of the request, 0 is OK
2773 */
2774 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Position &request) = 0;
2775
2776 /**
2777 * \brief Differential control with velocity average target and
2778 * position difference target using duty cycle control.
2779 *
2780 * - Diff_VelocityDutyCycle_Position Parameters:
2781 * - AverageRequest: Average VelocityDutyCYcle request of the mechanism.
2782 * - DifferentialRequest: Differential PositionDutyCycle request of the
2783 * mechanism.
2784 *
2785 * \param request Control object to request of the device
2786 * \returns Status Code of the request, 0 is OK
2787 */
2788 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Position &request) = 0;
2789
2790 /**
2791 * \brief Differential control with Motion Magic® average target and
2792 * position difference target using duty cycle control.
2793 *
2794 * - Diff_MotionMagicDutyCycle_Position Parameters:
2795 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
2796 * - DifferentialRequest: Differential PositionDutyCycle request of the
2797 * mechanism.
2798 *
2799 * \param request Control object to request of the device
2800 * \returns Status Code of the request, 0 is OK
2801 */
2802 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Position &request) = 0;
2803
2804 /**
2805 * \brief Differential control with Motion Magic® Expo average target
2806 * and position difference target using duty cycle control.
2807 *
2808 * - Diff_MotionMagicExpoDutyCycle_Position Parameters:
2809 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
2810 * mechanism.
2811 * - DifferentialRequest: Differential PositionDutyCycle request of the
2812 * mechanism.
2813 *
2814 * \param request Control object to request of the device
2815 * \returns Status Code of the request, 0 is OK
2816 */
2817 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Position &request) = 0;
2818
2819 /**
2820 * \brief Differential control with Motion Magic® Velocity average
2821 * target and position difference target using duty cycle control.
2822 *
2823 * - Diff_MotionMagicVelocityDutyCycle_Position Parameters:
2824 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
2825 * mechanism.
2826 * - DifferentialRequest: Differential PositionDutyCycle request of the
2827 * mechanism.
2828 *
2829 * \param request Control object to request of the device
2830 * \returns Status Code of the request, 0 is OK
2831 */
2832 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Position &request) = 0;
2833
2834 /**
2835 * \brief Differential control with duty cycle average target and
2836 * velocity difference target.
2837 *
2838 * - Diff_DutyCycleOut_Velocity Parameters:
2839 * - AverageRequest: Average DutyCycleOut request of the mechanism.
2840 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2841 * mechanism.
2842 *
2843 * \param request Control object to request of the device
2844 * \returns Status Code of the request, 0 is OK
2845 */
2846 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Velocity &request) = 0;
2847
2848 /**
2849 * \brief Differential control with position average target and
2850 * velocity difference target using duty cycle control.
2851 *
2852 * - Diff_PositionDutyCycle_Velocity Parameters:
2853 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
2854 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2855 * mechanism.
2856 *
2857 * \param request Control object to request of the device
2858 * \returns Status Code of the request, 0 is OK
2859 */
2860 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Velocity &request) = 0;
2861
2862 /**
2863 * \brief Differential control with velocity average target and
2864 * velocity difference target using duty cycle control.
2865 *
2866 * - Diff_VelocityDutyCycle_Velocity Parameters:
2867 * - AverageRequest: Average VelocityDutyCycle request of the mechanism.
2868 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2869 * mechanism.
2870 *
2871 * \param request Control object to request of the device
2872 * \returns Status Code of the request, 0 is OK
2873 */
2874 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Velocity &request) = 0;
2875
2876 /**
2877 * \brief Differential control with Motion Magic® average target and
2878 * velocity difference target using duty cycle control.
2879 *
2880 * - Diff_MotionMagicDutyCycle_Velocity Parameters:
2881 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
2882 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2883 * mechanism.
2884 *
2885 * \param request Control object to request of the device
2886 * \returns Status Code of the request, 0 is OK
2887 */
2888 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Velocity &request) = 0;
2889
2890 /**
2891 * \brief Differential control with Motion Magic® Expo average target
2892 * and velocity difference target using duty cycle control.
2893 *
2894 * - Diff_MotionMagicExpoDutyCycle_Velocity Parameters:
2895 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
2896 * mechanism.
2897 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2898 * mechanism.
2899 *
2900 * \param request Control object to request of the device
2901 * \returns Status Code of the request, 0 is OK
2902 */
2903 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Velocity &request) = 0;
2904
2905 /**
2906 * \brief Differential control with Motion Magic® Velocity average
2907 * target and velocity difference target using duty cycle control.
2908 *
2909 * - Diff_MotionMagicVelocityDutyCycle_Velocity Parameters:
2910 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
2911 * mechanism.
2912 * - DifferentialRequest: Differential VelocityDutyCycle request of the
2913 * mechanism.
2914 *
2915 * \param request Control object to request of the device
2916 * \returns Status Code of the request, 0 is OK
2917 */
2918 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Velocity &request) = 0;
2919
2920 /**
2921 * \brief Differential control with duty cycle average target and duty
2922 * cycle difference target.
2923 *
2924 * - Diff_DutyCycleOut_Open Parameters:
2925 * - AverageRequest: Average DutyCycleOut request of the mechanism.
2926 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2927 *
2928 * \param request Control object to request of the device
2929 * \returns Status Code of the request, 0 is OK
2930 */
2931 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Open &request) = 0;
2932
2933 /**
2934 * \brief Differential control with position average target and duty
2935 * cycle difference target.
2936 *
2937 * - Diff_PositionDutyCycle_Open Parameters:
2938 * - AverageRequest: Average PositionDutyCycle request of the mechanism.
2939 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2940 *
2941 * \param request Control object to request of the device
2942 * \returns Status Code of the request, 0 is OK
2943 */
2944 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Open &request) = 0;
2945
2946 /**
2947 * \brief Differential control with velocity average target and duty
2948 * cycle difference target.
2949 *
2950 * - Diff_VelocityDutyCycle_Open Parameters:
2951 * - AverageRequest: Average VelocityDutyCYcle request of the mechanism.
2952 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2953 *
2954 * \param request Control object to request of the device
2955 * \returns Status Code of the request, 0 is OK
2956 */
2957 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Open &request) = 0;
2958
2959 /**
2960 * \brief Differential control with Motion Magic® average target and
2961 * duty cycle difference target.
2962 *
2963 * - Diff_MotionMagicDutyCycle_Open Parameters:
2964 * - AverageRequest: Average MotionMagicDutyCycle request of the mechanism.
2965 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2966 *
2967 * \param request Control object to request of the device
2968 * \returns Status Code of the request, 0 is OK
2969 */
2970 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Open &request) = 0;
2971
2972 /**
2973 * \brief Differential control with Motion Magic® Expo average target
2974 * and duty cycle difference target.
2975 *
2976 * - Diff_MotionMagicExpoDutyCycle_Open Parameters:
2977 * - AverageRequest: Average MotionMagicExpoDutyCycle request of the
2978 * mechanism.
2979 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2980 *
2981 * \param request Control object to request of the device
2982 * \returns Status Code of the request, 0 is OK
2983 */
2984 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Open &request) = 0;
2985
2986 /**
2987 * \brief Differential control with Motion Magic® Velocity average
2988 * target and duty cycle difference target.
2989 *
2990 * - Diff_MotionMagicVelocityDutyCycle_Open Parameters:
2991 * - AverageRequest: Average MotionMagicVelocityDutyCycle request of the
2992 * mechanism.
2993 * - DifferentialRequest: Differential DutyCycleOut request of the mechanism.
2994 *
2995 * \param request Control object to request of the device
2996 * \returns Status Code of the request, 0 is OK
2997 */
2998 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Open &request) = 0;
2999
3000 /**
3001 * \brief Differential control with voltage average target and
3002 * position difference target.
3003 *
3004 * - Diff_VoltageOut_Position Parameters:
3005 * - AverageRequest: Average VoltageOut request of the mechanism.
3006 * - DifferentialRequest: Differential PositionVoltage request of the
3007 * mechanism.
3008 *
3009 * \param request Control object to request of the device
3010 * \returns Status Code of the request, 0 is OK
3011 */
3012 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Position &request) = 0;
3013
3014 /**
3015 * \brief Differential control with position average target and
3016 * position difference target using voltage control.
3017 *
3018 * - Diff_PositionVoltage_Position Parameters:
3019 * - AverageRequest: Average PositionVoltage request of the mechanism.
3020 * - DifferentialRequest: Differential PositionVoltage request of the
3021 * mechanism.
3022 *
3023 * \param request Control object to request of the device
3024 * \returns Status Code of the request, 0 is OK
3025 */
3026 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Position &request) = 0;
3027
3028 /**
3029 * \brief Differential control with velocity average target and
3030 * position difference target using voltage control.
3031 *
3032 * - Diff_VelocityVoltage_Position Parameters:
3033 * - AverageRequest: Average VelocityVoltage request of the mechanism.
3034 * - DifferentialRequest: Differential PositionVoltage request of the
3035 * mechanism.
3036 *
3037 * \param request Control object to request of the device
3038 * \returns Status Code of the request, 0 is OK
3039 */
3040 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Position &request) = 0;
3041
3042 /**
3043 * \brief Differential control with Motion Magic® average target and
3044 * position difference target using voltage control.
3045 *
3046 * - Diff_MotionMagicVoltage_Position Parameters:
3047 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
3048 * - DifferentialRequest: Differential PositionVoltage request of the
3049 * mechanism.
3050 *
3051 * \param request Control object to request of the device
3052 * \returns Status Code of the request, 0 is OK
3053 */
3054 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Position &request) = 0;
3055
3056 /**
3057 * \brief Differential control with Motion Magic® Expo average target
3058 * and position difference target using voltage control.
3059 *
3060 * - Diff_MotionMagicExpoVoltage_Position Parameters:
3061 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
3062 * - DifferentialRequest: Differential PositionVoltage request of the
3063 * mechanism.
3064 *
3065 * \param request Control object to request of the device
3066 * \returns Status Code of the request, 0 is OK
3067 */
3068 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Position &request) = 0;
3069
3070 /**
3071 * \brief Differential control with Motion Magic® Velocity average
3072 * target and position difference target using voltage control.
3073 *
3074 * - Diff_MotionMagicVelocityVoltage_Position Parameters:
3075 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
3076 * mechanism.
3077 * - DifferentialRequest: Differential PositionVoltage request of the
3078 * mechanism.
3079 *
3080 * \param request Control object to request of the device
3081 * \returns Status Code of the request, 0 is OK
3082 */
3083 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Position &request) = 0;
3084
3085 /**
3086 * \brief Differential control with voltage average target and
3087 * velocity difference target.
3088 *
3089 * - Diff_VoltageOut_Velocity Parameters:
3090 * - AverageRequest: Average VoltageOut request of the mechanism.
3091 * - DifferentialRequest: Differential VelocityVoltage request of the
3092 * mechanism.
3093 *
3094 * \param request Control object to request of the device
3095 * \returns Status Code of the request, 0 is OK
3096 */
3097 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Velocity &request) = 0;
3098
3099 /**
3100 * \brief Differential control with position average target and
3101 * velocity difference target using voltage control.
3102 *
3103 * - Diff_PositionVoltage_Velocity Parameters:
3104 * - AverageRequest: Average PositionVoltage request of the mechanism.
3105 * - DifferentialRequest: Differential VelocityVoltage request of the
3106 * mechanism.
3107 *
3108 * \param request Control object to request of the device
3109 * \returns Status Code of the request, 0 is OK
3110 */
3111 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Velocity &request) = 0;
3112
3113 /**
3114 * \brief Differential control with velocity average target and
3115 * velocity difference target using voltage control.
3116 *
3117 * - Diff_VelocityVoltage_Velocity Parameters:
3118 * - AverageRequest: Average VelocityVoltage request of the mechanism.
3119 * - DifferentialRequest: Differential VelocityVoltage request of the
3120 * mechanism.
3121 *
3122 * \param request Control object to request of the device
3123 * \returns Status Code of the request, 0 is OK
3124 */
3125 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Velocity &request) = 0;
3126
3127 /**
3128 * \brief Differential control with Motion Magic® average target and
3129 * velocity difference target using voltage control.
3130 *
3131 * - Diff_MotionMagicVoltage_Velocity Parameters:
3132 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
3133 * - DifferentialRequest: Differential VelocityVoltage request of the
3134 * mechanism.
3135 *
3136 * \param request Control object to request of the device
3137 * \returns Status Code of the request, 0 is OK
3138 */
3139 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Velocity &request) = 0;
3140
3141 /**
3142 * \brief Differential control with Motion Magic® Expo average target
3143 * and velocity difference target using voltage control.
3144 *
3145 * - Diff_MotionMagicExpoVoltage_Velocity Parameters:
3146 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
3147 * - DifferentialRequest: Differential VelocityVoltage request of the
3148 * mechanism.
3149 *
3150 * \param request Control object to request of the device
3151 * \returns Status Code of the request, 0 is OK
3152 */
3153 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Velocity &request) = 0;
3154
3155 /**
3156 * \brief Differential control with Motion Magic® Velocity average
3157 * target and velocity difference target using voltage control.
3158 *
3159 * - Diff_MotionMagicVelocityVoltage_Velocity Parameters:
3160 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
3161 * mechanism.
3162 * - DifferentialRequest: Differential VelocityVoltage request of the
3163 * mechanism.
3164 *
3165 * \param request Control object to request of the device
3166 * \returns Status Code of the request, 0 is OK
3167 */
3168 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Velocity &request) = 0;
3169
3170 /**
3171 * \brief Differential control with voltage average target and voltage
3172 * difference target.
3173 *
3174 * - Diff_VoltageOut_Open Parameters:
3175 * - AverageRequest: Average VoltageOut request of the mechanism.
3176 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3177 *
3178 * \param request Control object to request of the device
3179 * \returns Status Code of the request, 0 is OK
3180 */
3181 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Open &request) = 0;
3182
3183 /**
3184 * \brief Differential control with position average target and
3185 * voltage difference target.
3186 *
3187 * - Diff_PositionVoltage_Open Parameters:
3188 * - AverageRequest: Average PositionVoltage request of the mechanism.
3189 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3190 *
3191 * \param request Control object to request of the device
3192 * \returns Status Code of the request, 0 is OK
3193 */
3194 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Open &request) = 0;
3195
3196 /**
3197 * \brief Differential control with velocity average target and
3198 * voltage difference target.
3199 *
3200 * - Diff_VelocityVoltage_Open Parameters:
3201 * - AverageRequest: Average VelocityVoltage request of the mechanism.
3202 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3203 *
3204 * \param request Control object to request of the device
3205 * \returns Status Code of the request, 0 is OK
3206 */
3207 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Open &request) = 0;
3208
3209 /**
3210 * \brief Differential control with Motion Magic® average target and
3211 * voltage difference target.
3212 *
3213 * - Diff_MotionMagicVoltage_Open Parameters:
3214 * - AverageRequest: Average MotionMagicVoltage request of the mechanism.
3215 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3216 *
3217 * \param request Control object to request of the device
3218 * \returns Status Code of the request, 0 is OK
3219 */
3220 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Open &request) = 0;
3221
3222 /**
3223 * \brief Differential control with Motion Magic® Expo average target
3224 * and voltage difference target.
3225 *
3226 * - Diff_MotionMagicExpoVoltage_Open Parameters:
3227 * - AverageRequest: Average MotionMagicExpoVoltage request of the mechanism.
3228 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3229 *
3230 * \param request Control object to request of the device
3231 * \returns Status Code of the request, 0 is OK
3232 */
3233 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Open &request) = 0;
3234
3235 /**
3236 * \brief Differential control with Motion Magic® Velocity average
3237 * target and voltage difference target.
3238 *
3239 * - Diff_MotionMagicVelocityVoltage_Open Parameters:
3240 * - AverageRequest: Average MotionMagicVelocityVoltage request of the
3241 * mechanism.
3242 * - DifferentialRequest: Differential VoltageOut request of the mechanism.
3243 *
3244 * \param request Control object to request of the device
3245 * \returns Status Code of the request, 0 is OK
3246 */
3247 virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Open &request) = 0;
3248
3249 /**
3250 * \brief Control device with generic control request object. User must make
3251 * sure the specified object is castable to a valid control request,
3252 * otherwise this function will fail at run-time and return the NotSupported
3253 * StatusCode
3254 *
3255 * \param request Control object to request of the device
3256 * \returns Status Code of the request, 0 is OK
3257 */
3258 virtual ctre::phoenix::StatusCode SetControl(const controls::ControlRequest &request) = 0;
3259
3260};
3261
3262}
3263}
3264}
3265}
3266
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_MotionMagicExpoVoltage_Open.hpp
Diff_MotionMagicExpoVoltage_Position.hpp
Diff_MotionMagicExpoVoltage_Velocity.hpp
Diff_MotionMagicVelocityDutyCycle_Open.hpp
Diff_MotionMagicVelocityDutyCycle_Position.hpp
Diff_MotionMagicVelocityDutyCycle_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_PositionVoltage_Open.hpp
Diff_PositionVoltage_Position.hpp
Diff_PositionVoltage_Velocity.hpp
Diff_VelocityDutyCycle_Open.hpp
Diff_VelocityDutyCycle_Position.hpp
Diff_VelocityDutyCycle_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::controls::CoastOut
Request coast neutral output of actuator.
Definition CoastOut.hpp:21
ctre::phoenix6::controls::ControlRequest
Common interface implemented by all control requests.
Definition ControlRequest.hpp:27
ctre::phoenix6::controls::DifferentialDutyCycle
Request a specified motor duty cycle with a differential position closed-loop.
Definition DifferentialDutyCycle.hpp:26
ctre::phoenix6::controls::DifferentialFollower
Follow the differential motor output of another Talon.
Definition DifferentialFollower.hpp:29
ctre::phoenix6::controls::DifferentialMotionMagicDutyCycle
Requests Motion Magic® to target a final position using a motion profile, and PID to a differential p...
Definition DifferentialMotionMagicDutyCycle.hpp:30
ctre::phoenix6::controls::DifferentialMotionMagicExpoDutyCycle
Requests Motion Magic® to target a final position using an exponential motion profile,...
Definition DifferentialMotionMagicExpoDutyCycle.hpp:33
ctre::phoenix6::controls::DifferentialMotionMagicExpoVoltage
Requests Motion Magic® to target a final position using an exponential motion profile,...
Definition DifferentialMotionMagicExpoVoltage.hpp:32
ctre::phoenix6::controls::DifferentialMotionMagicVelocityDutyCycle
Requests Motion Magic® to target a final velocity using a motion profile, and PID to a differential p...
Definition DifferentialMotionMagicVelocityDutyCycle.hpp:35
ctre::phoenix6::controls::DifferentialMotionMagicVelocityVoltage
Requests Motion Magic® to target a final velocity using a motion profile, and PID to a differential p...
Definition DifferentialMotionMagicVelocityVoltage.hpp:34
ctre::phoenix6::controls::DifferentialMotionMagicVoltage
Requests Motion Magic® to target a final position using a motion profile, and PID to a differential p...
Definition DifferentialMotionMagicVoltage.hpp:29
ctre::phoenix6::controls::DifferentialPositionDutyCycle
Request PID to target position with a differential position setpoint.
Definition DifferentialPositionDutyCycle.hpp:24
ctre::phoenix6::controls::DifferentialPositionVoltage
Request PID to target position with a differential position setpoint.
Definition DifferentialPositionVoltage.hpp:24
ctre::phoenix6::controls::DifferentialStrictFollower
Follow the differential motor output of another Talon while ignoring the leader's invert setting.
Definition DifferentialStrictFollower.hpp:30
ctre::phoenix6::controls::DifferentialVelocityDutyCycle
Request PID to target velocity with a differential position setpoint.
Definition DifferentialVelocityDutyCycle.hpp:25
ctre::phoenix6::controls::DifferentialVelocityVoltage
Request PID to target velocity with a differential position setpoint.
Definition DifferentialVelocityVoltage.hpp:25
ctre::phoenix6::controls::DifferentialVoltage
Request a specified voltage with a differential position closed-loop.
Definition DifferentialVoltage.hpp:26
ctre::phoenix6::controls::DutyCycleOut
Request a specified motor duty cycle.
Definition DutyCycleOut.hpp:23
ctre::phoenix6::controls::DynamicMotionMagicDutyCycle
Requires Phoenix Pro and CANivore; Requests Motion Magic® to target a final position using a motion p...
Definition DynamicMotionMagicDutyCycle.hpp:36
ctre::phoenix6::controls::DynamicMotionMagicExpoDutyCycle
Requires Phoenix Pro and CANivore; Requests Motion Magic® Expo to target a final position using an ex...
Definition DynamicMotionMagicExpoDutyCycle.hpp:39
ctre::phoenix6::controls::DynamicMotionMagicExpoVoltage
Requires Phoenix Pro and CANivore; Requests Motion Magic® Expo to target a final position using an ex...
Definition DynamicMotionMagicExpoVoltage.hpp:38
ctre::phoenix6::controls::DynamicMotionMagicVoltage
Requires Phoenix Pro and CANivore; Requests Motion Magic® to target a final position using a motion p...
Definition DynamicMotionMagicVoltage.hpp:35
ctre::phoenix6::controls::Follower
Follow the motor output of another Talon.
Definition Follower.hpp:30
ctre::phoenix6::controls::MotionMagicDutyCycle
Requests Motion Magic® to target a final position using a motion profile.
Definition MotionMagicDutyCycle.hpp:31
ctre::phoenix6::controls::MotionMagicExpoDutyCycle
Requests Motion Magic® to target a final position using an exponential motion profile.
Definition MotionMagicExpoDutyCycle.hpp:34
ctre::phoenix6::controls::MotionMagicExpoVoltage
Requests Motion Magic® to target a final position using an exponential motion profile.
Definition MotionMagicExpoVoltage.hpp:33
ctre::phoenix6::controls::MotionMagicVelocityDutyCycle
Requests Motion Magic® to target a final velocity using a motion profile.
Definition MotionMagicVelocityDutyCycle.hpp:38
ctre::phoenix6::controls::MotionMagicVelocityVoltage
Requests Motion Magic® to target a final velocity using a motion profile.
Definition MotionMagicVelocityVoltage.hpp:37
ctre::phoenix6::controls::MotionMagicVoltage
Requests Motion Magic® to target a final position using a motion profile.
Definition MotionMagicVoltage.hpp:30
ctre::phoenix6::controls::NeutralOut
Request neutral output of actuator.
Definition NeutralOut.hpp:21
ctre::phoenix6::controls::PositionDutyCycle
Request PID to target position with duty cycle feedforward.
Definition PositionDutyCycle.hpp:26
ctre::phoenix6::controls::PositionVoltage
Request PID to target position with voltage feedforward.
Definition PositionVoltage.hpp:26
ctre::phoenix6::controls::StaticBrake
Applies full neutral-brake by shorting motor leads together.
Definition StaticBrake.hpp:20
ctre::phoenix6::controls::StrictFollower
Follow the motor output of another Talon while ignoring the leader's invert setting.
Definition StrictFollower.hpp:30
ctre::phoenix6::controls::VelocityDutyCycle
Request PID to target velocity with duty cycle feedforward.
Definition VelocityDutyCycle.hpp:26
ctre::phoenix6::controls::VelocityVoltage
Request PID to target velocity with voltage feedforward.
Definition VelocityVoltage.hpp:26
ctre::phoenix6::controls::VoltageOut
Request a specified voltage.
Definition VoltageOut.hpp:24
ctre::phoenix6::hardware::traits::CommonDevice
Contains everything common between Phoenix 6 devices.
Definition CommonDevice.hpp:23
ctre::phoenix6::hardware::traits::HasTalonControls
Contains all control functions available for devices that support Talon controls.
Definition HasTalonControls.hpp:96
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::Follower &request)=0
Follow the motor output of another Talon.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVelocityVoltage &request)=0
Request PID to target velocity with a differential position setpoint.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::NeutralOut &request)=0
Request neutral output of actuator.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicExpoVoltage &request)=0
Requests Motion Magic® to target a final position using an exponential motion profile,...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Velocity &request)=0
Differential control with voltage average target and velocity difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::ControlRequest &request)=0
Control device with generic control request object.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Position &request)=0
Differential control with velocity average target and position difference target using duty cycle con...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Position &request)=0
Differential control with position average target and position difference target using voltage contro...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicExpoDutyCycle &request)=0
Requests Motion Magic® to target a final position using an exponential motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::VelocityVoltage &request)=0
Request PID to target velocity with voltage feedforward.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialPositionDutyCycle &request)=0
Request PID to target position with a differential position setpoint.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicVoltage &request)=0
Requests Motion Magic® to target a final position using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVelocityDutyCycle &request)=0
Requests Motion Magic® to target a final velocity using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVelocityVoltage &request)=0
Requests Motion Magic® to target a final velocity using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Open &request)=0
Differential control with duty cycle average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Position &request)=0
Differential control with Motion Magic® Expo average target and position difference target using volt...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Open &request)=0
Differential control with velocity average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Open &request)=0
Differential control with Motion Magic® average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicDutyCycle &request)=0
Requests Motion Magic® to target a final position using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicExpoDutyCycle &request)=0
Requests Motion Magic® Expo to target a final position using an exponential motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Position &request)=0
Differential control with Motion Magic® Expo average target and position difference target using duty...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialStrictFollower &request)=0
Follow the differential motor output of another Talon while ignoring the leader's invert setting.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Velocity &request)=0
Differential control with Motion Magic® Velocity average target and velocity difference target using ...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Open &request)=0
Differential control with voltage average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Position &request)=0
Differential control with velocity average target and position difference target using voltage contro...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::PositionVoltage &request)=0
Request PID to target position with voltage feedforward.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Position &request)=0
Differential control with Motion Magic® Velocity average target and position difference target using ...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityDutyCycle_Velocity &request)=0
Differential control with velocity average target and velocity difference target using duty cycle con...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DutyCycleOut &request)=0
Request a specified motor duty cycle.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVoltage &request)=0
Request a specified voltage with a differential position closed-loop.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVoltage &request)=0
Requests Motion Magic® to target a final position using a motion profile, and PID to a differential p...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Open &request)=0
Differential control with Motion Magic® Velocity average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Velocity &request)=0
Differential control with Motion Magic® Expo average target and velocity difference target using volt...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Velocity &request)=0
Differential control with position average target and velocity difference target using duty cycle con...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Open &request)=0
Differential control with position average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::VelocityDutyCycle &request)=0
Request PID to target velocity with duty cycle feedforward.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVelocityDutyCycle &request)=0
Requests Motion Magic® to target a final velocity using a motion profile, and PID to a differential p...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VoltageOut_Position &request)=0
Differential control with voltage average target and position difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialFollower &request)=0
Follow the differential motor output of another Talon.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::StrictFollower &request)=0
Follow the motor output of another Talon while ignoring the leader's invert setting.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionVoltage_Velocity &request)=0
Differential control with position average target and velocity difference target using voltage contro...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicExpoVoltage &request)=0
Requests Motion Magic® to target a final position using an exponential motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Position &request)=0
Differential control with Motion Magic® average target and position difference target using duty cycl...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::CoastOut &request)=0
Request coast neutral output of actuator.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicDutyCycle &request)=0
Requests Motion Magic® to target a final position using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Velocity &request)=0
Differential control with Motion Magic® average target and velocity difference target using duty cycl...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialVelocityDutyCycle &request)=0
Request PID to target velocity with a differential position setpoint.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Velocity &request)=0
Differential control with Motion Magic® average target and velocity difference target using voltage c...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Open &request)=0
Differential control with position average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::PositionDutyCycle &request)=0
Request PID to target position with duty cycle feedforward.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DynamicMotionMagicExpoVoltage &request)=0
Requests Motion Magic® Expo to target a final position using an exponential motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicExpoDutyCycle &request)=0
Requests Motion Magic® to target a final position using an exponential motion profile,...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::VoltageOut &request)=0
Request a specified voltage.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Velocity &request)=0
Differential control with duty cycle average target and velocity difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityVoltage_Velocity &request)=0
Differential control with Motion Magic® Velocity average target and velocity difference target using ...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoVoltage_Open &request)=0
Differential control with Motion Magic® Expo average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Velocity &request)=0
Differential control with Motion Magic® Expo average target and velocity difference target using duty...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::MotionMagicVoltage &request)=0
Requests Motion Magic® to target a final position using a motion profile.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicDutyCycle_Open &request)=0
Differential control with Motion Magic® average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::StaticBrake &request)=0
Applies full neutral-brake by shorting motor leads together.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Open &request)=0
Differential control with Motion Magic® Velocity average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_PositionDutyCycle_Position &request)=0
Differential control with position average target and position difference target using duty cycle con...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialPositionVoltage &request)=0
Request PID to target position with a differential position setpoint.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicVelocityVoltage &request)=0
Requests Motion Magic® to target a final velocity using a motion profile, and PID to a differential p...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialDutyCycle &request)=0
Request a specified motor duty cycle with a differential position closed-loop.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicExpoDutyCycle_Open &request)=0
Differential control with Motion Magic® Expo average target and duty cycle difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVoltage_Position &request)=0
Differential control with Motion Magic® average target and position difference target using voltage c...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::DifferentialMotionMagicDutyCycle &request)=0
Requests Motion Magic® to target a final position using a motion profile, and PID to a differential p...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_MotionMagicVelocityDutyCycle_Position &request)=0
Differential control with Motion Magic® Velocity average target and position difference target using ...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Open &request)=0
Differential control with velocity average target and voltage difference target.
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_VelocityVoltage_Velocity &request)=0
Differential control with velocity average target and velocity difference target using voltage contro...
ctre::phoenix6::hardware::traits::HasTalonControls::SetControl
virtual ctre::phoenix::StatusCode SetControl(const controls::compound::Diff_DutyCycleOut_Position &request)=0
Differential control with duty cycle average target and position difference target.
ctre::phoenix::StatusCode
Status codes reported by APIs, including OK, warnings, and errors.
Definition StatusCodes.h:28
ctre
Definition motor_constants.h:14