CTRE Phoenix 6 C++ 24.50.0-alpha-2
DynamicMotionMagicVoltage.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
12#include <sstream>
13#include <units/angle.h>
14#include <units/angular_velocity.h>
15#include <units/angular_acceleration.h>
16#include <units/angular_jerk.h>
17#include <units/voltage.h>
18#include <units/frequency.h>
19#include <units/time.h>
20
21
22namespace ctre {
23namespace phoenix6 {
24namespace controls {
25
26/**
27 * Requires Phoenix Pro and CANivore;
28 * Requests Motion Magic® to target a final position using a motion profile.
29 * This dynamic request allows runtime changes to Cruise Velocity, Acceleration,
30 * and Jerk. Users can optionally provide a voltage feedforward. This control
31 * requires use of a CANivore.
32 *
33 * Motion Magic® produces a motion profile in real-time while attempting to honor the specified Cruise
34 * Velocity, Acceleration, and Jerk value. This control mode does not use the Expo_kV or Expo_kA configs.
35 *
36 * Target position can be changed on-the-fly and Motion Magic® will do its best to adjust the profile. This
37 * control mode is voltage-based, so relevant closed-loop gains will use Volts for the numerator.
38 */
40{
41 ctre::phoenix::StatusCode SendRequest(const char *network, uint32_t deviceHash, std::shared_ptr<ControlRequest> &req) override
42 {
43 if (req.get() != this)
44 {
45 auto const reqCast = dynamic_cast<DynamicMotionMagicVoltage *>(req.get());
46 if (reqCast != nullptr)
47 {
48 *reqCast = *this;
49 }
50 else
51 {
52 req = std::make_shared<DynamicMotionMagicVoltage>(*this);
53 }
54 }
55
56 return c_ctre_phoenix6_RequestControlDynamicMotionMagicVoltage(network, deviceHash, UpdateFreqHz.to<double>(), Position.to<double>(), Velocity.to<double>(), Acceleration.to<double>(), Jerk.to<double>(), EnableFOC, FeedForward.to<double>(), Slot, OverrideBrakeDurNeutral, LimitForwardMotion, LimitReverseMotion, UseTimesync);
57 }
58
59public:
60 /**
61 * Position to drive toward in rotations.
62 */
63 units::angle::turn_t Position;
64 /**
65 * Cruise velocity for profiling. The signage does not matter as the device
66 * will use the absolute value for profile generation.
67 */
68 units::angular_velocity::turns_per_second_t Velocity;
69 /**
70 * Acceleration for profiling. The signage does not matter as the device will
71 * use the absolute value for profile generation.
72 */
73 units::angular_acceleration::turns_per_second_squared_t Acceleration;
74 /**
75 * Jerk for profiling. The signage does not matter as the device will use the
76 * absolute value for profile generation.
77 */
78 units::angular_jerk::turns_per_second_cubed_t Jerk;
79 /**
80 * Set to true to use FOC commutation (requires Phoenix Pro), which increases
81 * peak power by ~15%. Set to false to use trapezoidal commutation.
82 *
83 * FOC improves motor performance by leveraging torque (current) control.
84 * However, this may be inconvenient for applications that require specifying
85 * duty cycle or voltage. CTR-Electronics has developed a hybrid method that
86 * combines the performances gains of FOC while still allowing applications to
87 * provide duty cycle or voltage demand. This not to be confused with simple
88 * sinusoidal control or phase voltage control which lacks the performance
89 * gains.
90 */
92 /**
93 * Feedforward to apply in volts
94 */
95 units::voltage::volt_t FeedForward;
96 /**
97 * Select which gains are applied by selecting the slot. Use the configuration
98 * api to set the gain values for the selected slot before enabling this
99 * feature. Slot must be within [0,2].
100 */
101 int Slot;
102 /**
103 * Set to true to static-brake the rotor when output is zero (or within
104 * deadband). Set to false to use the NeutralMode configuration setting
105 * (default). This flag exists to provide the fundamental behavior of this
106 * control when output is zero, which is to provide 0V to the motor.
107 */
109 /**
110 * Set to true to force forward limiting. This allows users to use other limit
111 * switch sensors connected to robot controller. This also allows use of active
112 * sensors that require external power.
113 */
115 /**
116 * Set to true to force reverse limiting. This allows users to use other limit
117 * switch sensors connected to robot controller. This also allows use of active
118 * sensors that require external power.
119 */
121 /**
122 * Set to true to delay applying this control request until a timesync boundary
123 * (requires Phoenix Pro and CANivore). This eliminates the impact of
124 * nondeterministic network delays in exchange for a larger but deterministic
125 * control latency.
126 */
128
129 /**
130 * \brief The period at which this control will update at.
131 * This is designated in Hertz, with a minimum of 20 Hz
132 * (every 50 ms) and a maximum of 1000 Hz (every 1 ms).
133 *
134 * If this field is set to 0 Hz, the control request will
135 * be sent immediately as a one-shot frame. This may be useful
136 * for advanced applications that require outputs to be
137 * synchronized with data acquisition. In this case, we
138 * recommend not exceeding 50 ms between control calls.
139 */
140 units::frequency::hertz_t UpdateFreqHz{100_Hz}; // Default to 100_Hz
141
142 /**
143 * \brief Requires Phoenix Pro and CANivore;
144 * Requests Motion Magic® to target a final position using a motion
145 * profile. This dynamic request allows runtime changes to Cruise
146 * Velocity, Acceleration, and Jerk. Users can optionally provide a
147 * voltage feedforward. This control requires use of a CANivore.
148 *
149 * \details Motion Magic® produces a motion profile in real-time while
150 * attempting to honor the specified Cruise Velocity, Acceleration, and
151 * Jerk value. This control mode does not use the Expo_kV or Expo_kA
152 * configs.
153 *
154 * Target position can be changed on-the-fly and Motion Magic® will do
155 * its best to adjust the profile. This control mode is voltage-based,
156 * so relevant closed-loop gains will use Volts for the numerator.
157 *
158 * \param Position Position to drive toward in rotations.
159 * \param Velocity Cruise velocity for profiling. The signage does not
160 * matter as the device will use the absolute value for
161 * profile generation.
162 * \param Acceleration Acceleration for profiling. The signage does not
163 * matter as the device will use the absolute value for
164 * profile generation.
165 * \param Jerk Jerk for profiling. The signage does not matter as the device
166 * will use the absolute value for profile generation.
167 * \param EnableFOC Set to true to use FOC commutation (requires Phoenix
168 * Pro), which increases peak power by ~15%. Set to false to
169 * use trapezoidal commutation.
170 *
171 * FOC improves motor performance by leveraging torque
172 * (current) control. However, this may be inconvenient for
173 * applications that require specifying duty cycle or
174 * voltage. CTR-Electronics has developed a hybrid method
175 * that combines the performances gains of FOC while still
176 * allowing applications to provide duty cycle or voltage
177 * demand. This not to be confused with simple sinusoidal
178 * control or phase voltage control which lacks the
179 * performance gains.
180 * \param FeedForward Feedforward to apply in volts
181 * \param Slot Select which gains are applied by selecting the slot. Use the
182 * configuration api to set the gain values for the selected slot
183 * before enabling this feature. Slot must be within [0,2].
184 * \param OverrideBrakeDurNeutral Set to true to static-brake the rotor when
185 * output is zero (or within deadband). Set
186 * to false to use the NeutralMode
187 * configuration setting (default). This flag
188 * exists to provide the fundamental behavior
189 * of this control when output is zero, which
190 * is to provide 0V to the motor.
191 * \param LimitForwardMotion Set to true to force forward limiting. This
192 * allows users to use other limit switch sensors
193 * connected to robot controller. This also allows
194 * use of active sensors that require external
195 * power.
196 * \param LimitReverseMotion Set to true to force reverse limiting. This
197 * allows users to use other limit switch sensors
198 * connected to robot controller. This also allows
199 * use of active sensors that require external
200 * power.
201 * \param UseTimesync Set to true to delay applying this control request
202 * until a timesync boundary (requires Phoenix Pro and
203 * CANivore). This eliminates the impact of
204 * nondeterministic network delays in exchange for a
205 * larger but deterministic control latency.
206 */
207 DynamicMotionMagicVoltage(units::angle::turn_t Position, units::angular_velocity::turns_per_second_t Velocity, units::angular_acceleration::turns_per_second_squared_t Acceleration, units::angular_jerk::turns_per_second_cubed_t Jerk, bool EnableFOC = true, units::voltage::volt_t FeedForward = 0.0_V, int Slot = 0, bool OverrideBrakeDurNeutral = false, bool LimitForwardMotion = false, bool LimitReverseMotion = false, bool UseTimesync = false) : ControlRequest{"DynamicMotionMagicVoltage"},
208 Position{std::move(Position)},
209 Velocity{std::move(Velocity)},
211 Jerk{std::move(Jerk)},
212 EnableFOC{std::move(EnableFOC)},
214 Slot{std::move(Slot)},
219 {}
220
221 /**
222 * \brief Modifies this Control Request's Position parameter and returns itself for
223 * method-chaining and easier to use request API.
224 *
225 * Position to drive toward in rotations.
226 *
227 * \param newPosition Parameter to modify
228 * \returns Itself
229 */
230 DynamicMotionMagicVoltage& WithPosition(units::angle::turn_t newPosition)
231 {
232 Position = std::move(newPosition);
233 return *this;
234 }
235
236 /**
237 * \brief Modifies this Control Request's Velocity parameter and returns itself for
238 * method-chaining and easier to use request API.
239 *
240 * Cruise velocity for profiling. The signage does not matter as the device
241 * will use the absolute value for profile generation.
242 *
243 * \param newVelocity Parameter to modify
244 * \returns Itself
245 */
246 DynamicMotionMagicVoltage& WithVelocity(units::angular_velocity::turns_per_second_t newVelocity)
247 {
248 Velocity = std::move(newVelocity);
249 return *this;
250 }
251
252 /**
253 * \brief Modifies this Control Request's Acceleration parameter and returns itself for
254 * method-chaining and easier to use request API.
255 *
256 * Acceleration for profiling. The signage does not matter as the device will
257 * use the absolute value for profile generation.
258 *
259 * \param newAcceleration Parameter to modify
260 * \returns Itself
261 */
262 DynamicMotionMagicVoltage& WithAcceleration(units::angular_acceleration::turns_per_second_squared_t newAcceleration)
263 {
264 Acceleration = std::move(newAcceleration);
265 return *this;
266 }
267
268 /**
269 * \brief Modifies this Control Request's Jerk parameter and returns itself for
270 * method-chaining and easier to use request API.
271 *
272 * Jerk for profiling. The signage does not matter as the device will use the
273 * absolute value for profile generation.
274 *
275 * \param newJerk Parameter to modify
276 * \returns Itself
277 */
278 DynamicMotionMagicVoltage& WithJerk(units::angular_jerk::turns_per_second_cubed_t newJerk)
279 {
280 Jerk = std::move(newJerk);
281 return *this;
282 }
283
284 /**
285 * \brief Modifies this Control Request's EnableFOC parameter and returns itself for
286 * method-chaining and easier to use request API.
287 *
288 * Set to true to use FOC commutation (requires Phoenix Pro), which increases
289 * peak power by ~15%. Set to false to use trapezoidal commutation.
290 *
291 * FOC improves motor performance by leveraging torque (current) control.
292 * However, this may be inconvenient for applications that require specifying
293 * duty cycle or voltage. CTR-Electronics has developed a hybrid method that
294 * combines the performances gains of FOC while still allowing applications to
295 * provide duty cycle or voltage demand. This not to be confused with simple
296 * sinusoidal control or phase voltage control which lacks the performance
297 * gains.
298 *
299 * \param newEnableFOC Parameter to modify
300 * \returns Itself
301 */
303 {
304 EnableFOC = std::move(newEnableFOC);
305 return *this;
306 }
307
308 /**
309 * \brief Modifies this Control Request's FeedForward parameter and returns itself for
310 * method-chaining and easier to use request API.
311 *
312 * Feedforward to apply in volts
313 *
314 * \param newFeedForward Parameter to modify
315 * \returns Itself
316 */
317 DynamicMotionMagicVoltage& WithFeedForward(units::voltage::volt_t newFeedForward)
318 {
319 FeedForward = std::move(newFeedForward);
320 return *this;
321 }
322
323 /**
324 * \brief Modifies this Control Request's Slot parameter and returns itself for
325 * method-chaining and easier to use request API.
326 *
327 * Select which gains are applied by selecting the slot. Use the configuration
328 * api to set the gain values for the selected slot before enabling this
329 * feature. Slot must be within [0,2].
330 *
331 * \param newSlot Parameter to modify
332 * \returns Itself
333 */
335 {
336 Slot = std::move(newSlot);
337 return *this;
338 }
339
340 /**
341 * \brief Modifies this Control Request's OverrideBrakeDurNeutral parameter and returns itself for
342 * method-chaining and easier to use request API.
343 *
344 * Set to true to static-brake the rotor when output is zero (or within
345 * deadband). Set to false to use the NeutralMode configuration setting
346 * (default). This flag exists to provide the fundamental behavior of this
347 * control when output is zero, which is to provide 0V to the motor.
348 *
349 * \param newOverrideBrakeDurNeutral Parameter to modify
350 * \returns Itself
351 */
353 {
354 OverrideBrakeDurNeutral = std::move(newOverrideBrakeDurNeutral);
355 return *this;
356 }
357
358 /**
359 * \brief Modifies this Control Request's LimitForwardMotion parameter and returns itself for
360 * method-chaining and easier to use request API.
361 *
362 * Set to true to force forward limiting. This allows users to use other limit
363 * switch sensors connected to robot controller. This also allows use of active
364 * sensors that require external power.
365 *
366 * \param newLimitForwardMotion Parameter to modify
367 * \returns Itself
368 */
370 {
371 LimitForwardMotion = std::move(newLimitForwardMotion);
372 return *this;
373 }
374
375 /**
376 * \brief Modifies this Control Request's LimitReverseMotion parameter and returns itself for
377 * method-chaining and easier to use request API.
378 *
379 * Set to true to force reverse limiting. This allows users to use other limit
380 * switch sensors connected to robot controller. This also allows use of active
381 * sensors that require external power.
382 *
383 * \param newLimitReverseMotion Parameter to modify
384 * \returns Itself
385 */
387 {
388 LimitReverseMotion = std::move(newLimitReverseMotion);
389 return *this;
390 }
391
392 /**
393 * \brief Modifies this Control Request's UseTimesync parameter and returns itself for
394 * method-chaining and easier to use request API.
395 *
396 * Set to true to delay applying this control request until a timesync boundary
397 * (requires Phoenix Pro and CANivore). This eliminates the impact of
398 * nondeterministic network delays in exchange for a larger but deterministic
399 * control latency.
400 *
401 * \param newUseTimesync Parameter to modify
402 * \returns Itself
403 */
405 {
406 UseTimesync = std::move(newUseTimesync);
407 return *this;
408 }
409 /**
410 * \brief Sets the period at which this control will update at.
411 * This is designated in Hertz, with a minimum of 20 Hz
412 * (every 50 ms) and a maximum of 1000 Hz (every 1 ms).
413 *
414 * If this field is set to 0 Hz, the control request will
415 * be sent immediately as a one-shot frame. This may be useful
416 * for advanced applications that require outputs to be
417 * synchronized with data acquisition. In this case, we
418 * recommend not exceeding 50 ms between control calls.
419 *
420 * \param newUpdateFreqHz Parameter to modify
421 * \returns Itself
422 */
423 DynamicMotionMagicVoltage &WithUpdateFreqHz(units::frequency::hertz_t newUpdateFreqHz)
424 {
425 UpdateFreqHz = newUpdateFreqHz;
426 return *this;
427 }
428 /**
429 * Returns a string representation of the object.
430 *
431 * \returns a string representation of the object.
432 */
433 std::string ToString() const override
434 {
435 std::stringstream ss;
436 ss << "Control: DynamicMotionMagicVoltage" << std::endl;
437 ss << " Position: " << Position.to<double>() << " rotations" << std::endl;
438 ss << " Velocity: " << Velocity.to<double>() << " rotations per second" << std::endl;
439 ss << " Acceleration: " << Acceleration.to<double>() << " rotations per second²" << std::endl;
440 ss << " Jerk: " << Jerk.to<double>() << " rotations per second³" << std::endl;
441 ss << " EnableFOC: " << EnableFOC << std::endl;
442 ss << " FeedForward: " << FeedForward.to<double>() << " Volts" << std::endl;
443 ss << " Slot: " << Slot << std::endl;
444 ss << " OverrideBrakeDurNeutral: " << OverrideBrakeDurNeutral << std::endl;
445 ss << " LimitForwardMotion: " << LimitForwardMotion << std::endl;
446 ss << " LimitReverseMotion: " << LimitReverseMotion << std::endl;
447 ss << " UseTimesync: " << UseTimesync << std::endl;
448 return ss.str();
449 }
450
451 /**
452 * \brief Gets information about this control request.
453 *
454 * \returns Map of control parameter names and corresponding applied values
455 */
456 std::map<std::string, std::string> GetControlInfo() const override
457 {
458 std::map<std::string, std::string> controlInfo;
459 std::stringstream ss;
460 controlInfo["Name"] = GetName();
461 ss << Position.to<double>(); controlInfo["Position"] = ss.str(); ss.str(std::string{});
462 ss << Velocity.to<double>(); controlInfo["Velocity"] = ss.str(); ss.str(std::string{});
463 ss << Acceleration.to<double>(); controlInfo["Acceleration"] = ss.str(); ss.str(std::string{});
464 ss << Jerk.to<double>(); controlInfo["Jerk"] = ss.str(); ss.str(std::string{});
465 ss << EnableFOC; controlInfo["EnableFOC"] = ss.str(); ss.str(std::string{});
466 ss << FeedForward.to<double>(); controlInfo["FeedForward"] = ss.str(); ss.str(std::string{});
467 ss << Slot; controlInfo["Slot"] = ss.str(); ss.str(std::string{});
468 ss << OverrideBrakeDurNeutral; controlInfo["OverrideBrakeDurNeutral"] = ss.str(); ss.str(std::string{});
469 ss << LimitForwardMotion; controlInfo["LimitForwardMotion"] = ss.str(); ss.str(std::string{});
470 ss << LimitReverseMotion; controlInfo["LimitReverseMotion"] = ss.str(); ss.str(std::string{});
471 ss << UseTimesync; controlInfo["UseTimesync"] = ss.str(); ss.str(std::string{});
472 return controlInfo;
473 }
474};
475
476}
477}
478}
479
CTREXPORT int c_ctre_phoenix6_RequestControlDynamicMotionMagicVoltage(const char *canbus, uint32_t ecuEncoding, double updateTime, double Position, double Velocity, double Acceleration, double Jerk, bool EnableFOC, double FeedForward, int Slot, bool OverrideBrakeDurNeutral, bool LimitForwardMotion, bool LimitReverseMotion, bool UseTimesync)
Abstract Control Request class that other control requests extend for use.
Definition: ControlRequest.hpp:29
std::string const & GetName() const
Definition: ControlRequest.hpp:52
Requires Phoenix Pro and CANivore; Requests Motion Magic® to target a final position using a motion p...
Definition: DynamicMotionMagicVoltage.hpp:40
units::angular_acceleration::turns_per_second_squared_t Acceleration
Acceleration for profiling.
Definition: DynamicMotionMagicVoltage.hpp:73
DynamicMotionMagicVoltage & WithEnableFOC(bool newEnableFOC)
Modifies this Control Request's EnableFOC parameter and returns itself for method-chaining and easier...
Definition: DynamicMotionMagicVoltage.hpp:302
units::voltage::volt_t FeedForward
Feedforward to apply in volts.
Definition: DynamicMotionMagicVoltage.hpp:95
DynamicMotionMagicVoltage & WithLimitForwardMotion(bool newLimitForwardMotion)
Modifies this Control Request's LimitForwardMotion parameter and returns itself for method-chaining a...
Definition: DynamicMotionMagicVoltage.hpp:369
DynamicMotionMagicVoltage & WithPosition(units::angle::turn_t newPosition)
Modifies this Control Request's Position parameter and returns itself for method-chaining and easier ...
Definition: DynamicMotionMagicVoltage.hpp:230
bool LimitReverseMotion
Set to true to force reverse limiting.
Definition: DynamicMotionMagicVoltage.hpp:120
DynamicMotionMagicVoltage & WithLimitReverseMotion(bool newLimitReverseMotion)
Modifies this Control Request's LimitReverseMotion parameter and returns itself for method-chaining a...
Definition: DynamicMotionMagicVoltage.hpp:386
units::angular_jerk::turns_per_second_cubed_t Jerk
Jerk for profiling.
Definition: DynamicMotionMagicVoltage.hpp:78
DynamicMotionMagicVoltage & WithOverrideBrakeDurNeutral(bool newOverrideBrakeDurNeutral)
Modifies this Control Request's OverrideBrakeDurNeutral parameter and returns itself for method-chain...
Definition: DynamicMotionMagicVoltage.hpp:352
std::string ToString() const override
Returns a string representation of the object.
Definition: DynamicMotionMagicVoltage.hpp:433
DynamicMotionMagicVoltage & WithUseTimesync(bool newUseTimesync)
Modifies this Control Request's UseTimesync parameter and returns itself for method-chaining and easi...
Definition: DynamicMotionMagicVoltage.hpp:404
units::frequency::hertz_t UpdateFreqHz
The period at which this control will update at.
Definition: DynamicMotionMagicVoltage.hpp:140
bool OverrideBrakeDurNeutral
Set to true to static-brake the rotor when output is zero (or within deadband).
Definition: DynamicMotionMagicVoltage.hpp:108
bool EnableFOC
Set to true to use FOC commutation (requires Phoenix Pro), which increases peak power by ~15%.
Definition: DynamicMotionMagicVoltage.hpp:91
bool LimitForwardMotion
Set to true to force forward limiting.
Definition: DynamicMotionMagicVoltage.hpp:114
DynamicMotionMagicVoltage & WithFeedForward(units::voltage::volt_t newFeedForward)
Modifies this Control Request's FeedForward parameter and returns itself for method-chaining and easi...
Definition: DynamicMotionMagicVoltage.hpp:317
DynamicMotionMagicVoltage & WithAcceleration(units::angular_acceleration::turns_per_second_squared_t newAcceleration)
Modifies this Control Request's Acceleration parameter and returns itself for method-chaining and eas...
Definition: DynamicMotionMagicVoltage.hpp:262
DynamicMotionMagicVoltage & WithJerk(units::angular_jerk::turns_per_second_cubed_t newJerk)
Modifies this Control Request's Jerk parameter and returns itself for method-chaining and easier to u...
Definition: DynamicMotionMagicVoltage.hpp:278
bool UseTimesync
Set to true to delay applying this control request until a timesync boundary (requires Phoenix Pro an...
Definition: DynamicMotionMagicVoltage.hpp:127
units::angle::turn_t Position
Position to drive toward in rotations.
Definition: DynamicMotionMagicVoltage.hpp:63
DynamicMotionMagicVoltage(units::angle::turn_t Position, units::angular_velocity::turns_per_second_t Velocity, units::angular_acceleration::turns_per_second_squared_t Acceleration, units::angular_jerk::turns_per_second_cubed_t Jerk, bool EnableFOC=true, units::voltage::volt_t FeedForward=0.0_V, int Slot=0, bool OverrideBrakeDurNeutral=false, bool LimitForwardMotion=false, bool LimitReverseMotion=false, bool UseTimesync=false)
Requires Phoenix Pro and CANivore; Requests Motion Magic® to target a final position using a motion p...
Definition: DynamicMotionMagicVoltage.hpp:207
DynamicMotionMagicVoltage & WithUpdateFreqHz(units::frequency::hertz_t newUpdateFreqHz)
Sets the period at which this control will update at.
Definition: DynamicMotionMagicVoltage.hpp:423
int Slot
Select which gains are applied by selecting the slot.
Definition: DynamicMotionMagicVoltage.hpp:101
DynamicMotionMagicVoltage & WithVelocity(units::angular_velocity::turns_per_second_t newVelocity)
Modifies this Control Request's Velocity parameter and returns itself for method-chaining and easier ...
Definition: DynamicMotionMagicVoltage.hpp:246
std::map< std::string, std::string > GetControlInfo() const override
Gets information about this control request.
Definition: DynamicMotionMagicVoltage.hpp:456
DynamicMotionMagicVoltage & WithSlot(int newSlot)
Modifies this Control Request's Slot parameter and returns itself for method-chaining and easier to u...
Definition: DynamicMotionMagicVoltage.hpp:334
units::angular_velocity::turns_per_second_t Velocity
Cruise velocity for profiling.
Definition: DynamicMotionMagicVoltage.hpp:68
Status codes reported by APIs, including OK, warnings, and errors.
Definition: StatusCodes.h:27
Represents the state of one swerve module.
Definition: StatusCodes.h:18
Definition: span.hpp:401