HF-TMC9660 Driver
Hardware Agnostic C++ Driver for the TMC9660
Loading...
Searching...
No Matches
tmc9660_param_mode_tmcl.hpp
Go to the documentation of this file.
1// clang-format off
2//====================================================================================================================
3// @file TMC9660TmclCommands.hpp
4// @brief Enumerations and helpers for **TMCL® operation & reply codes** when the TMC9660 is used
5// in *Parameter Mode*.
6//
7// --------------------------------------------------------------------------------------------------
8// © 2025 <Nebiyu Tadesse>. Released under the GNU GPL V3 License.
9//====================================================================================================================
10#pragma once
11
12#include <cstdint>
13
14namespace tmc9660::tmcl {
15
16
18// //
19// ████████╗███╗ ███╗ ██████╗██╗ █████╗ ██████╗ ██╗ //
20// ╚══██╔══╝████╗ ████║██╔════╝██║ ██╔══██╗██╔══██╗██║ //
21// ██║ ██╔████╔██║██║ ██║ ███████║██████╔╝██║ //
22// ██║ ██║╚██╔╝██║██║ ██║ ██╔══██║██╔═══╝ ██║ //
23// ██║ ██║ ╚═╝ ██║╚██████╗███████╗ ██║ ██║██║ ██║ //
24// ╚═╝ ╚═╝ ╚═╝ ╚═════╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ //
25// //
26//==================================================================================================================//
27// TMCL API SECTION //
28//==================================================================================================================//
30
32// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
33// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
34// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
36
37//--------------------------------------
38// TMCL operation codes (Table 18)
39//--------------------------------------
100#define OP_LIST(X) \
101 X(NOP, 0, ) \
102 X(MST, 3, ) \
103 X(SAP, 5, ) \
104 X(GAP, 6, ) \
105 X(STAP, 7, ) \
106 X(SGP, 9, ) \
107 X(GGP, 10, ) \
108 X(RFS, 13, ) \
109 X(SIO, 14, ) \
110 X(GIO, 15, ) \
111 X(CALC, 19, ) \
112 X(COMP, 20, ) \
113 X(JC, 21, ) \
114 X(JA, 22, ) \
115 X(CSUB, 23, ) \
116 X(RSUB, 24, ) \
117 X(EI, 25, ) \
118 X(DI, 26, ) \
119 X(WAIT, 27, ) \
120 X(STOP, 28, ) \
121 X(CALCX, 33, ) \
122 X(AAP, 34, ) \
123 X(AGP, 35, ) \
124 X(CLE, 36, ) \
125 X(VECT, 37, ) \
126 X(RETI, 38, ) \
127 X(CALCVV, 40, ) \
128 X(CALCVA, 41, ) \
129 X(CALCAV, 42, ) \
130 X(CALCVX, 43, ) \
131 X(CALCXV, 44, ) \
132 X(CALCV, 45, ) \
133 X(RST, 48, ) \
134 X(DJNZ, 49, ) \
135 X(SIV, 55, ) \
136 X(GIV, 56, ) \
137 X(AIV, 57, ) \
138 X(ApplStop, 128, ) \
139 X(ApplRun, 129, ) \
140 X(ApplStep, 130, ) \
141 X(ApplReset, 131, ) \
142 X(DownloadStart, 132, ) \
143 X(DownloadEnd, 133, ) \
144 X(ReadMem, 134, ) \
145 X(GetStatusScript, 135, ) \
146 X(GetVersion, 136, ) \
147 X(FactoryDefault, 137, ) \
148 X(Breakpoint, 141, ) \
149 X(RamDebug, 142, ) \
150 X(GetInfo, 157, ) \
151 X(Boot, 242, )
152
153enum class Op : std::uint8_t {
154 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
155 OP_LIST(X)
156 #undef X
157};
158
159inline const char* to_string(Op op) {
160 switch(op) {
161 #define X(NAME, VALUE, DOC) case Op::NAME: return #NAME;
162 OP_LIST(X)
163 #undef X
164 default: return "UNKNOWN";
165 }
166}
167#undef OP_LIST
168
169//--------------------------------------
170// Arithmetic operation types for CALC
171//--------------------------------------
172#define CALC_OPERATION_LIST(X) \
173 X(CALC_ADD, 0, ) \
174 X(CALC_SUB, 1, ) \
175 X(CALC_MUL, 2, ) \
176 X(CALC_DIV, 3, ) \
177 X(CALC_MOD, 4, ) \
178 X(CALC_AND, 5, ) \
179 X(CALC_OR, 6, ) \
180 X(CALC_XOR, 7, ) \
181 X(CALC_NOT, 8, ) \
182 X(CALC_LOAD,9, )
183
184enum class CalcOperation : std::uint8_t {
185 #define X(NAME, VALUE, DOC) NAME = VALUE,
186 CALC_OPERATION_LIST(X)
187 #undef X
188};
189
190inline const char* to_string(CalcOperation op) {
191 switch(op) {
192 #define X(NAME, VALUE, DOC) case CalcOperation::NAME: return #NAME;
193 CALC_OPERATION_LIST(X)
194 #undef X
195 default: return "UNKNOWN";
196 }
197}
198#undef CALC_OPERATION_LIST
199
200//--------------------------------------
201// Conditional jump conditions for JC
202//--------------------------------------
203#define JUMP_CONDITION_LIST(X) \
204 X(JC_ZERO, 0, ) \
205 X(JC_NOT_ZERO, 1, ) \
206 X(JC_EQUAL, 2, ) \
207 X(JC_NOT_EQUAL, 3, ) \
208 X(JC_GREATER, 4, ) \
209 X(JC_GREATER_EQ, 5, ) \
210 X(JC_LOWER, 6, ) \
211 X(JC_LOWER_EQ, 7, ) \
212 X(JC_TIMEOUT, 8, )
213
214enum class JumpCondition : std::uint8_t {
215 #define X(NAME, VALUE, DOC) NAME = VALUE,
216 JUMP_CONDITION_LIST(X)
217 #undef X
218};
219
220inline const char* to_string(JumpCondition c) {
221 switch(c) {
222 #define X(NAME, VALUE, DOC) case JumpCondition::NAME: return #NAME;
223 JUMP_CONDITION_LIST(X)
224 #undef X
225 default: return "UNKNOWN";
226 }
227}
228#undef JUMP_CONDITION_LIST
229
230//--------------------------------------
231// WAIT event conditions
232//--------------------------------------
233#define WAIT_CONDITION_LIST(X) \
234 X(WAIT_TIME, 0, ) \
235 X(WAIT_RFS, 4, ) \
236 X(WAIT_LATCH, 5, ) \
237 X(WAIT_VEL_REACHED, 6, ) \
238 X(WAIT_POS_REACHED, 7, ) \
239 X(WAIT_STOP_LEFT, 8, ) \
240 X(WAIT_STOP_RIGHT, 9, ) \
241 X(WAIT_STOP_HOME, 10, )
242
243enum class WaitCondition : std::uint8_t {
244 #define X(NAME, VALUE, DOC) NAME = VALUE,
245 WAIT_CONDITION_LIST(X)
246 #undef X
247};
248
249inline const char* to_string(WaitCondition w) {
250 switch(w) {
251 #define X(NAME, VALUE, DOC) case WaitCondition::NAME: return #NAME;
252 WAIT_CONDITION_LIST(X)
253 #undef X
254 default: return "UNKNOWN";
255 }
256}
257#undef WAIT_CONDITION_LIST
258
259//--------------------------------------
260// TMCL reply codes (Table 19)
261//--------------------------------------
279#define REPLY_CODE_LIST(X) \
280 X(REPLY_OK, 100, ) \
281 X(REPLY_CMD_LOADED, 101, ) \
282 X(REPLY_CHKERR, 1, ) \
283 X(REPLY_INVALID_CMD, 2, ) \
284 X(REPLY_WRONG_TYPE, 3, ) \
285 X(REPLY_INVALID_VALUE, 4, ) \
286 X(REPLY_CMD_NOT_AVAILABLE, 6, ) \
287 X(REPLY_CMD_LOAD_ERROR, 7, ) \
288 X(REPLY_MAX_EXCEEDED, 9, ) \
289 X(REPLY_DOWNLOAD_NOT_POSSIBLE, 10, )
290
291enum class ReplyCode : std::uint8_t {
292 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
293 REPLY_CODE_LIST(X)
294 #undef X
295};
296
297inline const char* to_string(ReplyCode rc) {
298 switch(rc) {
299 #define X(NAME, VALUE, DOC) case ReplyCode::NAME: return #NAME;
300 REPLY_CODE_LIST(X)
301 #undef X
302 default: return "UNKNOWN";
303 }
304}
305#undef REPLY_CODE_LIST
306
307//--------------------------------------
308// RAMDebug sub‑commands / type codes (Table 16)
309//--------------------------------------
333#define RAMDEBUG_TYPE_LIST(X) \
334 X(INITIALISE_RESET, 0, ) \
335 X(SET_SAMPLE_COUNT, 1, ) \
336 X(SET_PRESCALER, 3, ) \
337 X(SET_CHANNEL, 4, ) \
338 X(SET_TRIGGER_CHANNEL, 5, ) \
339 X(SET_TRIGGER_MASK_SHIFT, 6, ) \
340 X(ENABLE_TRIGGER, 7, ) \
341 X(GET_STATE, 8, ) \
342 X(READ_SAMPLE, 9, ) \
343 X(GET_INFO, 10, ) \
344 X(GET_CHANNEL_TYPE, 11, ) \
345 X(GET_CHANNEL_ADDRESS, 12, ) \
346 X(SET_PRETRIGGER_COUNT, 13, ) \
347 X(GET_PRETRIGGER_COUNT, 14, )
348
349enum class RamDebugType : std::uint8_t {
350 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
351 RAMDEBUG_TYPE_LIST(X)
352 #undef X
353};
354
355inline const char* to_string(RamDebugType t) {
356 switch(t) {
357 #define X(NAME, VALUE, DOC) case RamDebugType::NAME: return #NAME;
358 RAMDEBUG_TYPE_LIST(X)
359 #undef X
360 default: return "UNKNOWN";
361 }
362}
363#undef RAMDEBUG_TYPE_LIST
364
365//--------------------------------------
366// RAMDebug state machine (Table 17)
367//--------------------------------------
381#define RAMDEBUG_STATE_LIST(X) \
382 X(IDLE, 0, ) \
383 X(TRIGGER, 1, ) \
384 X(CAPTURE, 2, ) \
385 X(COMPLETE, 3, ) \
386 X(PRETRIGGER, 4, )
387
388enum class RamDebugState : std::uint8_t {
389 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
390 RAMDEBUG_STATE_LIST(X)
391 #undef X
392};
393
394inline const char* to_string(RamDebugState s) {
395 switch(s) {
396 #define X(NAME, VALUE, DOC) case RamDebugState::NAME: return #NAME;
397 RAMDEBUG_STATE_LIST(X)
398 #undef X
399 default: return "UNKNOWN";
400 }
401}
402#undef RAMDEBUG_STATE_LIST
403
404
406// //
407// ██████╗ ██╗ ██████╗ ██████╗ █████╗ ██╗ ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
408// ██╔════╝ ██║ ██╔═══██╗██╔══██╗██╔══██╗██║ ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
409// ██║ ███╗██║ ██║ ██║██████╔╝███████║██║ ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
410// ██║ ██║██║ ██║ ██║██╔══██╗██╔══██║██║ ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
411// ╚██████╔╝███████╗╚██████╔╝██████╔╝██║ ██║███████╗ ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
412// ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
413// //
414//==================================================================================================================//
415// GLOBAL PARAMETERS SECTION //
416//==================================================================================================================//
418
420// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
421// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
422// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
424
425//--------------------------------------
426// Global Parameters – Bank 0 (System Settings)
427//--------------------------------------
433#define GLOBAL_PARAM_BANK0_LIST(X) \
434 X(SERIAL_ADDRESS, 1, ) \
435 X(SERIAL_HOST_ADDRESS, 2, ) \
436 X(HEARTBEAT_MONITORING_CONFIG, 3, ) \
437 X(HEARTBEAT_MONITORING_TIMEOUT, 4, ) \
438 X(IO_DIRECTION_MASK, 5, ) \
439 X(IO_INPUT_PULLUP_PULLDOWN_ENABLE_MASK, 6, ) \
440 X(IO_INPUT_PULLUP_PULLDOWN_DIRECTION_MASK, 7, ) \
441 X(WAKE_PIN_CONTROL_ENABLE, 10, ) \
442 X(GO_TO_TIMEOUT_POWER_DOWN_STATE, 11, ) \
443 X(MAIN_LOOPS, 12, ) \
444 X(TORQUE_LOOPS, 13, ) \
445 X(VELOCITY_LOOPS, 14, ) \
446 X(AUTO_START_ENABLE, 77, ) \
447 X(CLEAR_USER_VARIABLES, 85, )
448
449enum class GlobalParamBank0 : std::uint16_t {
450 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
451 GLOBAL_PARAM_BANK0_LIST(X)
452 #undef X
453};
454
455inline const char* to_string(GlobalParamBank0 p) {
456 switch(p) {
457 #define X(NAME, VALUE, DOC) case GlobalParamBank0::NAME: return #NAME;
458 GLOBAL_PARAM_BANK0_LIST(X)
459 #undef X
460 default: return "UNKNOWN";
461 }
462}
463#undef GLOBAL_PARAM_BANK0_LIST
464
465//--------------------------------------
466// Global Parameters – Bank 2 (User Variables)
467//--------------------------------------
471#define GLOBAL_PARAM_BANK2_LIST(X) \
472 X(USER_VARIABLE_0, 0, ) \
473 X(USER_VARIABLE_1, 1, ) \
474 X(USER_VARIABLE_2, 2, ) \
475 X(USER_VARIABLE_3, 3, ) \
476 X(USER_VARIABLE_4, 4, ) \
477 X(USER_VARIABLE_5, 5, ) \
478 X(USER_VARIABLE_6, 6, ) \
479 X(USER_VARIABLE_7, 7, ) \
480 X(USER_VARIABLE_8, 8, ) \
481 X(USER_VARIABLE_9, 9, ) \
482 X(USER_VARIABLE_10, 10, ) \
483 X(USER_VARIABLE_11, 11, ) \
484 X(USER_VARIABLE_12, 12, ) \
485 X(USER_VARIABLE_13, 13, ) \
486 X(USER_VARIABLE_14, 14, ) \
487 X(USER_VARIABLE_15, 15, )
488
489enum class GlobalParamBank2 : std::uint16_t {
490 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
491 GLOBAL_PARAM_BANK2_LIST(X)
492 #undef X
493};
494
495inline const char* to_string(GlobalParamBank2 p) {
496 switch(p) {
497 #define X(NAME, VALUE, DOC) case GlobalParamBank2::NAME: return #NAME;
498 GLOBAL_PARAM_BANK2_LIST(X)
499 #undef X
500 default: return "UNKNOWN";
501 }
502}
503#undef GLOBAL_PARAM_BANK2_LIST
504
505//--------------------------------------
506// Global Parameters – Bank 3 (Interrupt & Trigger Configuration)
507//--------------------------------------
511#define GLOBAL_PARAM_BANK3_LIST(X) \
512 X(TIMER_0_PERIOD, 0, ) \
513 X(TIMER_1_PERIOD, 1, ) \
514 X(TIMER_2_PERIOD, 2, ) \
515 X(STOP_LEFT_TRIGGER_TRANSITION, 10, ) \
516 X(STOP_RIGHT_TRIGGER_TRANSITION, 11, ) \
517 X(HOME_TRIGGER_TRANSITION, 12, ) \
518 X(INPUT_0_TRIGGER_TRANSITION, 13, ) \
519 X(INPUT_1_TRIGGER_TRANSITION, 14, ) \
520 X(INPUT_2_TRIGGER_TRANSITION, 15, ) \
521 X(INPUT_3_TRIGGER_TRANSITION, 16, ) \
522 X(INPUT_4_TRIGGER_TRANSITION, 17, ) \
523 X(INPUT_5_TRIGGER_TRANSITION, 18, ) \
524 X(INPUT_6_TRIGGER_TRANSITION, 19, ) \
525 X(INPUT_7_TRIGGER_TRANSITION, 20, ) \
526 X(INPUT_8_TRIGGER_TRANSITION, 21, ) \
527 X(INPUT_9_TRIGGER_TRANSITION, 22, ) \
528 X(INPUT_10_TRIGGER_TRANSITION, 23, ) \
529 X(INPUT_11_TRIGGER_TRANSITION, 24, ) \
530 X(INPUT_12_TRIGGER_TRANSITION, 25, ) \
531 X(INPUT_13_TRIGGER_TRANSITION, 26, ) \
532 X(INPUT_14_TRIGGER_TRANSITION, 27, ) \
533 X(INPUT_15_TRIGGER_TRANSITION, 28, ) \
534 X(INPUT_16_TRIGGER_TRANSITION, 29, ) \
535 X(INPUT_17_TRIGGER_TRANSITION, 30, ) \
536 X(INPUT_18_TRIGGER_TRANSITION, 31, )
537
538enum class GlobalParamBank3 : std::uint16_t {
539 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
540 GLOBAL_PARAM_BANK3_LIST(X)
541 #undef X
542};
543
544inline const char* to_string(GlobalParamBank3 p) {
545 switch(p) {
546 #define X(NAME, VALUE, DOC) case GlobalParamBank3::NAME: return #NAME;
547 GLOBAL_PARAM_BANK3_LIST(X)
548 #undef X
549 default: return "UNKNOWN";
550 }
551}
552#undef GLOBAL_PARAM_BANK3_LIST
553
555// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
556// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
557// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
559
562//--------------------------------------
563// Trigger Transition Options
564//--------------------------------------
575#define TRIGGER_TRANSITION_LIST(X) \
576 X(OFF, 0, ) \
577 X(RISING, 1, ) \
578 X(FALLING, 2, ) \
579 X(BOTH, 3, )
580
581enum class TriggerTransition : uint8_t {
582 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
583 TRIGGER_TRANSITION_LIST(X)
584 #undef X
585};
586
587inline const char* to_string(TriggerTransition e) {
588 switch(e) {
589 #define X(NAME, VALUE, DOC) case TriggerTransition::NAME: return #NAME;
590 TRIGGER_TRANSITION_LIST(X)
591 #undef X
592 default: return "UNKNOWN";
593 }
594}
595#undef TRIGGER_TRANSITION_LIST
597
599// //
600// ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
601// ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
602// ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
603// ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
604// ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
605// ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
606// //
607//==================================================================================================================//
608// PARAMETERS //
609//==================================================================================================================//
611
613// //
614// ██████╗ █████╗ ████████╗███████╗ ██████╗ ██████╗ ██╗██╗ ██╗███████╗██████╗ ███████╗ //
615// ██╔════╝ ██╔══██╗╚══██╔══╝██╔════╝ ██╔══██╗██╔══██╗██║██║ ██║██╔════╝██╔══██╗██╔════╝ //
616// ██║ ███╗███████║ ██║ █████╗ ██║ ██║██████╔╝██║██║ ██║█████╗ ██████╔╝███████╗ //
617// ██║ ██║██╔══██║ ██║ ██╔══╝ ██║ ██║██╔══██╗██║╚██╗ ██╔╝██╔══╝ ██╔══██╗╚════██║ //
618// ╚██████╔╝██║ ██║ ██║ ███████╗ ██████╔╝██║ ██║██║ ╚████╔╝ ███████╗██║ ██║███████║ //
619// ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚══════╝ //
620// //
621//==================================================================================================================//
622// GATE DRIVER SECTION //
623//==================================================================================================================//
625
627// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
628// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
629// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
631
632//--------------------------------------
633// Gate Driver Parameters (Table 20)
634//--------------------------------------
662#define GATE_DRIVER_LIST(X) \
663 X(PWM_L_OUTPUT_POLARITY, 233, ) \
664 X(PWM_H_OUTPUT_POLARITY, 234, ) \
665 X(BREAK_BEFORE_MAKE_TIME_LOW_UVW, 235, ) \
666 X(BREAK_BEFORE_MAKE_TIME_HIGH_UVW, 236, ) \
667 X(BREAK_BEFORE_MAKE_TIME_LOW_Y2, 237, ) \
668 X(BREAK_BEFORE_MAKE_TIME_HIGH_Y2, 238, ) \
669 X(USE_ADAPTIVE_DRIVE_TIME_UVW, 239, ) \
670 X(USE_ADAPTIVE_DRIVE_TIME_Y2, 240, ) \
671 X(DRIVE_TIME_SINK_UVW, 241, ) \
672 X(DRIVE_TIME_SOURCE_UVW, 242, ) \
673 X(DRIVE_TIME_SINK_Y2, 243, ) \
674 X(DRIVE_TIME_SOURCE_Y2, 244, ) \
675 X(UVW_SINK_CURRENT, 245, ) \
676 X(UVW_SOURCE_CURRENT, 246, ) \
677 X(Y2_SINK_CURRENT, 247, ) \
678 X(Y2_SOURCE_CURRENT, 248, ) \
679 X(BOOTSTRAP_CURRENT_LIMIT, 249, )
680
681enum class GateDriver : uint16_t {
682 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
683 GATE_DRIVER_LIST(X)
684 #undef X
685};
686
687inline const char* to_string(GateDriver gd) {
688 switch (gd) {
689 #define X(NAME, VALUE, DOC) case GateDriver::NAME: return #NAME;
690 GATE_DRIVER_LIST(X)
691 #undef X
692 default: return "UNKNOWN";
693 }
694}
695
696
698// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
699// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
700// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
702//--------------------------------------
703// PWM Output Polarity (Table)
704//--------------------------------------
714#define PWM_OUTPUT_POLARITY_LIST(X) \
715 X(ACTIVE_HIGH, 0, ) \
716 X(ACTIVE_LOW, 1, )
717
718enum class PwmOutputPolarity : std::uint8_t {
719 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
720 PWM_OUTPUT_POLARITY_LIST(X)
721 #undef X
722};
723
724inline const char* to_string(PwmOutputPolarity p) {
725 switch(p) {
726 #define X(NAME, VALUE, DOC) case PwmOutputPolarity::NAME: return #NAME;
727 PWM_OUTPUT_POLARITY_LIST(X)
728 #undef X
729 default: return "UNKNOWN";
730 }
731}
732#undef PWM_OUTPUT_POLARITY_LIST
733
734//--------------------------------------
735// Gate Current Sink (Table)
736//--------------------------------------
760#define GATE_CURRENT_SINK_LIST(X) \
761 X(CUR_50_MA, 0, ) \
762 X(CUR_100_MA, 1, ) \
763 X(CUR_160_MA, 2, ) \
764 X(CUR_210_MA, 3, ) \
765 X(CUR_270_MA, 4, ) \
766 X(CUR_320_MA, 5, ) \
767 X(CUR_380_MA, 6, ) \
768 X(CUR_430_MA, 7, ) \
769 X(CUR_580_MA, 8, ) \
770 X(CUR_720_MA, 9, ) \
771 X(CUR_860_MA, 10, ) \
772 X(CUR_1000_MA, 11, ) \
773 X(CUR_1250_MA, 12, ) \
774 X(CUR_1510_MA, 13, ) \
775 X(CUR_1770_MA, 14, ) \
776 X(CUR_2000_MA, 15, )
777
778enum class GateCurrentSink : std::uint8_t {
779 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
780 GATE_CURRENT_SINK_LIST(X)
781 #undef X
782};
783
784inline const char* to_string(GateCurrentSink s) {
785 switch(s) {
786 #define X(NAME, VALUE, DOC) case GateCurrentSink::NAME: return #NAME;
787 GATE_CURRENT_SINK_LIST(X)
788 #undef X
789 default: return "UNKNOWN";
790 }
791}
792#undef GATE_CURRENT_SINK_LIST
793
794//--------------------------------------
795// Gate Current Source (Table)
796//--------------------------------------
820#define GATE_CURRENT_SOURCE_LIST(X) \
821 X(CUR_25_MA, 0, ) \
822 X(CUR_50_MA, 1, ) \
823 X(CUR_80_MA, 2, ) \
824 X(CUR_105_MA, 3, ) \
825 X(CUR_135_MA, 4, ) \
826 X(CUR_160_MA, 5, ) \
827 X(CUR_190_MA, 6, ) \
828 X(CUR_215_MA, 7, ) \
829 X(CUR_290_MA, 8, ) \
830 X(CUR_360_MA, 9, ) \
831 X(CUR_430_MA, 10, ) \
832 X(CUR_500_MA, 11, ) \
833 X(CUR_625_MA, 12, ) \
834 X(CUR_755_MA, 13, ) \
835 X(CUR_855_MA, 14, ) \
836 X(CUR_1000_MA, 15, )
837
838enum class GateCurrentSource : std::uint8_t {
839 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
840 GATE_CURRENT_SOURCE_LIST(X)
841 #undef X
842};
843
844inline const char* to_string(GateCurrentSource s) {
845 switch(s) {
846 #define X(NAME, VALUE, DOC) case GateCurrentSource::NAME: return #NAME;
847 GATE_CURRENT_SOURCE_LIST(X)
848 #undef X
849 default: return "UNKNOWN";
850 }
851}
852#undef GATE_CURRENT_SOURCE_LIST
853
854//--------------------------------------
855// Bootstrap Current Limit (Table)
856//--------------------------------------
872#define BOOTSTRAP_CURRENT_LIMIT_LIST(X) \
873 X(CUR_45_MA, 0, ) \
874 X(CUR_91_MA, 1, ) \
875 X(CUR_141_MA, 2, ) \
876 X(CUR_191_MA, 3, ) \
877 X(CUR_267_MA, 4, ) \
878 X(CUR_292_MA, 5, ) \
879 X(CUR_341_MA, 6, ) \
880 X(CUR_391_MA, 7, )
881
882enum class BootstrapCurrentLimit : std::uint8_t {
883 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
884 BOOTSTRAP_CURRENT_LIMIT_LIST(X)
885 #undef X
886};
887
888inline const char* to_string(BootstrapCurrentLimit s) {
889 switch(s) {
890 #define X(NAME, VALUE, DOC) case BootstrapCurrentLimit::NAME: return #NAME;
891 BOOTSTRAP_CURRENT_LIMIT_LIST(X)
892 #undef X
893 default: return "UNKNOWN";
894 }
895}
896#undef BOOTSTRAP_CURRENT_LIMIT_LIST
897
899// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
900// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
901// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
903
904//--------------------------------------
905// Gate Driver Overcurrent Protection
906//--------------------------------------
935#define OVERCURRENT_PROTECTION_LIST(X) \
936 X(UVW_LOW_SIDE_ENABLE, 254, ) \
937 X(UVW_HIGH_SIDE_ENABLE, 255, ) \
938 X(Y2_LOW_SIDE_ENABLE, 256, ) \
939 X(Y2_HIGH_SIDE_ENABLE, 257, ) \
940 X(UVW_LOW_SIDE_THRESHOLD, 258, ) \
941 X(UVW_HIGH_SIDE_THRESHOLD, 259, ) \
942 X(Y2_LOW_SIDE_THRESHOLD, 260, ) \
943 X(Y2_HIGH_SIDE_THRESHOLD, 261, ) \
944 X(UVW_LOW_SIDE_BLANKING, 262, ) \
945 X(UVW_HIGH_SIDE_BLANKING, 263, ) \
946 X(Y2_LOW_SIDE_BLANKING, 264, ) \
947 X(Y2_HIGH_SIDE_BLANKING, 265, ) \
948 X(UVW_LOW_SIDE_DEGLITCH, 266, ) \
949 X(UVW_HIGH_SIDE_DEGLITCH, 267, ) \
950 X(Y2_LOW_SIDE_DEGLITCH, 268, ) \
951 X(Y2_HIGH_SIDE_DEGLITCH, 269, ) \
952 X(UVW_LOW_SIDE_USE_VDS, 270, ) \
953 X(Y2_LOW_SIDE_USE_VDS, 271, )
954
955enum class OvercurrentProtection : uint16_t {
956 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
957 OVERCURRENT_PROTECTION_LIST(X)
958 #undef X
959};
960
961inline const char* to_string(OvercurrentProtection p) {
962 switch(p) {
963 #define X(NAME, VALUE, DOC) case OvercurrentProtection::NAME: return #NAME;
964 OVERCURRENT_PROTECTION_LIST(X)
965 #undef X
966 default: return "UNKNOWN";
967 }
968}
969
971// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
972// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
973// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
975
976//--------------------------------------
977// Overcurrent Protection Enable/Disable
978//--------------------------------------
988#define OVERCURRENT_ENABLE_LIST(X) \
989 X(DISABLED, 0, ) \
990 X(ENABLED, 1, )
991
992enum class OvercurrentEnable : std::uint8_t {
993 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
994 OVERCURRENT_ENABLE_LIST(X)
995 #undef X
996};
997
998inline const char* to_string(OvercurrentEnable e) {
999 switch(e) {
1000 #define X(NAME, VALUE, DOC) case OvercurrentEnable::NAME: return #NAME;
1001 OVERCURRENT_ENABLE_LIST(X)
1002 #undef X
1003 default: return "UNKNOWN";
1004 }
1005}
1006#undef OVERCURRENT_ENABLE_LIST
1007
1008//--------------------------------------
1009// Overcurrent Protection Thresholds
1010//--------------------------------------
1034#define OVERCURRENT_THRESHOLD_LIST(X) \
1035 X(V_63_MILLIVOLT, 0, ) \
1036 X(V_125_MILLIVOLT, 1, ) \
1037 X(V_187_MILLIVOLT, 2, ) \
1038 X(V_248_MILLIVOLT, 3, ) \
1039 X(V_312_MILLIVOLT, 4, ) \
1040 X(V_374_MILLIVOLT, 5, ) \
1041 X(V_434_MILLIVOLT, 6, ) \
1042 X(V_504_MILLIVOLT, 7, ) \
1043 X(V_705_MILLIVOLT, 8, ) \
1044 X(V_940_MILLIVOLT, 9, ) \
1045 X(V_1180_MILLIVOLT, 10, ) \
1046 X(V_1410_MILLIVOLT, 11, ) \
1047 X(V_1650_MILLIVOLT, 12, ) \
1048 X(V_1880_MILLIVOLT, 13, ) \
1049 X(V_2110_MILLIVOLT, 14, ) \
1050 X(V_2350_MILLIVOLT, 15, )
1051
1052enum class OvercurrentThreshold : std::uint8_t {
1053 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1054 OVERCURRENT_THRESHOLD_LIST(X)
1055 #undef X
1056};
1057
1058inline const char* to_string(OvercurrentThreshold t) {
1059 switch(t) {
1060 #define X(NAME, VALUE, DOC) case OvercurrentThreshold::NAME: return #NAME;
1061 OVERCURRENT_THRESHOLD_LIST(X)
1062 #undef X
1063 default: return "UNKNOWN";
1064 }
1065}
1066#undef OVERCURRENT_THRESHOLD_LIST
1067
1068//--------------------------------------
1069// Overcurrent Protection Blanking and Deglitch Times
1070//--------------------------------------
1086#define OVERCURRENT_TIMING_LIST(X) \
1087 X(OFF, 0, ) \
1088 X(T_0_25_MICROSEC, 1, ) \
1089 X(T_0_5_MICROSEC, 2, ) \
1090 X(T_1_MICROSEC, 3, ) \
1091 X(T_2_MICROSEC, 4, ) \
1092 X(T_4_MICROSEC, 5, ) \
1093 X(T_6_MICROSEC, 6, ) \
1094 X(T_8_MICROSEC, 7, )
1095
1096enum class OvercurrentTiming : std::uint8_t {
1097 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1098 OVERCURRENT_TIMING_LIST(X)
1099 #undef X
1100};
1101
1102inline const char* to_string(OvercurrentTiming t) {
1103 switch(t) {
1104 #define X(NAME, VALUE, DOC) case OvercurrentTiming::NAME: return #NAME;
1105 OVERCURRENT_TIMING_LIST(X)
1106 #undef X
1107 default: return "UNKNOWN";
1108 }
1109}
1110#undef OVERCURRENT_TIMING_LIST
1111
1112//--------------------------------------
1113// VDS Measurement Enable/Disable
1114//--------------------------------------
1124#define VDS_USAGE_LIST(X) \
1125 X(DISABLED, 0, ) \
1126 X(ENABLED, 1, )
1127
1128enum class VdsUsage : std::uint8_t {
1129 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1130 VDS_USAGE_LIST(X)
1131 #undef X
1132};
1133
1134inline const char* to_string(VdsUsage v) {
1135 switch(v) {
1136 #define X(NAME, VALUE, DOC) case VdsUsage::NAME: return #NAME;
1137 VDS_USAGE_LIST(X)
1138 #undef X
1139 default: return "UNKNOWN";
1140 }
1141}
1142#undef VDS_USAGE_LIST
1143
1145// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1146// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1147// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1149
1150//--------------------------------------
1151// Undervoltage Protection Parameters
1152//--------------------------------------
1167#define UNDERVOLTAGE_PROTECTION_LIST(X) \
1168 X(SUPPLY_LEVEL, 250, ) \
1169 X(VDRV_ENABLE, 251, ) \
1170 X(BST_UVW_ENABLE, 252, ) \
1171 X(BST_Y2_ENABLE, 253, )
1172
1173enum class UndervoltageProtection : uint16_t {
1174 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1175 UNDERVOLTAGE_PROTECTION_LIST(X)
1176 #undef X
1177};
1178
1179inline const char* to_string(UndervoltageProtection p) {
1180 switch(p) {
1181 #define X(NAME, VALUE, DOC) case UndervoltageProtection::NAME: return #NAME;
1182 UNDERVOLTAGE_PROTECTION_LIST(X)
1183 #undef X
1184 default: return "UNKNOWN";
1185 }
1186}
1187
1189// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1190// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1191// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1193
1194//--------------------------------------
1195// Undervoltage Protection Levels
1196//--------------------------------------
1223#define UNDERVOLTAGE_LEVEL_LIST(X) \
1224 X(DISABLED, 0, ) \
1225 X(LEVEL_0, 1, ) \
1226 X(LEVEL_1, 2, ) \
1227 X(LEVEL_2, 3, ) \
1228 X(LEVEL_3, 4, ) \
1229 X(LEVEL_4, 5, ) \
1230 X(LEVEL_5, 6, ) \
1231 X(LEVEL_6, 7, ) \
1232 X(LEVEL_7, 8, ) \
1233 X(LEVEL_8, 9, ) \
1234 X(LEVEL_9, 10, ) \
1235 X(LEVEL_10, 11, ) \
1236 X(LEVEL_11, 12, ) \
1237 X(LEVEL_12, 13, ) \
1238 X(LEVEL_13, 14, ) \
1239 X(LEVEL_14, 15, ) \
1240 X(LEVEL_15, 16, )
1241
1242enum class UndervoltageLevel : std::uint8_t {
1243 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1244 UNDERVOLTAGE_LEVEL_LIST(X)
1245 #undef X
1246};
1247
1248inline const char* to_string(UndervoltageLevel level) {
1249 switch(level) {
1250 #define X(NAME, VALUE, DOC) case UndervoltageLevel::NAME: return #NAME;
1251 UNDERVOLTAGE_LEVEL_LIST(X)
1252 #undef X
1253 default: return "UNKNOWN";
1254 }
1255}
1256#undef UNDERVOLTAGE_LEVEL_LIST
1257
1258//--------------------------------------
1259// Undervoltage Protection Enable/Disable
1260//--------------------------------------
1270#define UNDERVOLTAGE_ENABLE_LIST(X) \
1271 X(DISABLED, 0, ) \
1272 X(ENABLED, 1, )
1273
1274enum class UndervoltageEnable : std::uint8_t {
1275 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1276 UNDERVOLTAGE_ENABLE_LIST(X)
1277 #undef X
1278};
1279
1280inline const char* to_string(UndervoltageEnable enable) {
1281 switch(enable) {
1282 #define X(NAME, VALUE, DOC) case UndervoltageEnable::NAME: return #NAME;
1283 UNDERVOLTAGE_ENABLE_LIST(X)
1284 #undef X
1285 default: return "UNKNOWN";
1286 }
1287}
1288#undef UNDERVOLTAGE_ENABLE_LIST
1289
1291// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1292// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1293// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1295
1296//--------------------------------------
1297// Gate Short (VGS) Protection Parameters
1298//--------------------------------------
1306#define VGS_SHORT_PROTECTION_LIST(X) \
1307 X(UVW_LOW_SIDE_ON_ENABLE, 272, ) \
1308 X(UVW_LOW_SIDE_OFF_ENABLE, 273, ) \
1309 X(UVW_HIGH_SIDE_ON_ENABLE, 274, ) \
1310 X(UVW_HIGH_SIDE_OFF_ENABLE,275, ) \
1311 X(Y2_LOW_SIDE_ON_ENABLE, 276, ) \
1312 X(Y2_LOW_SIDE_OFF_ENABLE, 277, ) \
1313 X(Y2_HIGH_SIDE_ON_ENABLE, 278, ) \
1314 X(Y2_HIGH_SIDE_OFF_ENABLE, 279, ) \
1315 X(UVW_BLANKING, 280, ) \
1316 X(Y2_BLANKING, 281, ) \
1317 X(UVW_DEGLITCH, 282, ) \
1318 X(Y2_DEGLITCH, 283, )
1319
1320enum class VgsShortProtection : uint16_t {
1321 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1322 VGS_SHORT_PROTECTION_LIST(X)
1323 #undef X
1324};
1325
1326inline const char* to_string(VgsShortProtection p) {
1327 switch(p) {
1328 #define X(NAME, VALUE, DOC) case VgsShortProtection::NAME: return #NAME;
1329 VGS_SHORT_PROTECTION_LIST(X)
1330 #undef X
1331 default: return "UNKNOWN";
1332 }
1333}
1334
1336// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1337// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1338// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1340
1341//--------------------------------------
1342// VGS Protection Enable/Disable
1343//--------------------------------------
1353#define VGS_SHORT_ENABLE_LIST(X) \
1354 X(DISABLED, 0, ) \
1355 X(ENABLED, 1, )
1356
1357enum class VgsShortEnable : uint8_t {
1358 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1359 VGS_SHORT_ENABLE_LIST(X)
1360 #undef X
1361};
1362
1363inline const char* to_string(VgsShortEnable e) {
1364 switch(e) {
1365 #define X(NAME, VALUE, DOC) case VgsShortEnable::NAME: return #NAME;
1366 VGS_SHORT_ENABLE_LIST(X)
1367 #undef X
1368 default: return "UNKNOWN";
1369 }
1370}
1371#undef VGS_SHORT_ENABLE_LIST
1372
1373//--------------------------------------
1374// VGS Protection Blanking Time
1375//--------------------------------------
1387#define VGS_BLANKING_TIME_LIST(X) \
1388 X(OFF, 0, ) \
1389 X(T_0_25_MICROSEC, 1, ) \
1390 X(T_0_5_MICROSEC, 2, ) \
1391 X(T_1_MICROSEC, 3, )
1392
1393enum class VgsBlankingTime : uint8_t {
1394 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1395 VGS_BLANKING_TIME_LIST(X)
1396 #undef X
1397};
1398
1399inline const char* to_string(VgsBlankingTime t) {
1400 switch(t) {
1401 #define X(NAME, VALUE, DOC) case VgsBlankingTime::NAME: return #NAME;
1402 VGS_BLANKING_TIME_LIST(X)
1403 #undef X
1404 default: return "UNKNOWN";
1405 }
1406}
1407#undef VGS_BLANKING_TIME_LIST
1408
1409//--------------------------------------
1410// VGS Protection Deglitch Time
1411//--------------------------------------
1427#define VGS_DEGLITCH_TIME_LIST(X) \
1428 X(OFF, 0, ) \
1429 X(T_0_25_MICROSEC, 1, ) \
1430 X(T_0_5_MICROSEC, 2, ) \
1431 X(T_1_MICROSEC, 3, ) \
1432 X(T_2_MICROSEC, 4, ) \
1433 X(T_4_MICROSEC, 5, ) \
1434 X(T_6_MICROSEC, 6, ) \
1435 X(T_8_MICROSEC, 7, )
1436
1437enum class VgsDeglitchTime : uint8_t {
1438 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1439 VGS_DEGLITCH_TIME_LIST(X)
1440 #undef X
1441};
1442
1443inline const char* to_string(VgsDeglitchTime t) {
1444 switch(t) {
1445 #define X(NAME, VALUE, DOC) case VgsDeglitchTime::NAME: return #NAME;
1446 VGS_DEGLITCH_TIME_LIST(X)
1447 #undef X
1448 default: return "UNKNOWN";
1449 }
1450}
1451#undef VGS_DEGLITCH_TIME_LIST
1452
1454// //
1455// ███╗ ███╗ ██████╗ ████████╗ ██████╗ ██████╗ ██████╗ ██████╗ ███╗ ██╗███████╗██╗ ██████╗ //
1456// ████╗ ████║██╔═══██╗╚══██╔══╝██╔═══██╗██╔══██╗ ██╔════╝██╔═══██╗████╗ ██║██╔════╝██║██╔════╝ //
1457// ██╔████╔██║██║ ██║ ██║ ██║ ██║██████╔╝ ██║ ██║ ██║██╔██╗ ██║█████╗ ██║██║ ███╗ //
1458// ██║╚██╔╝██║██║ ██║ ██║ ██║ ██║██╔══██╗ ██║ ██║ ██║██║╚██╗██║██╔══╝ ██║██║ ██║ //
1459// ██║ ╚═╝ ██║╚██████╔╝ ██║ ╚██████╔╝██║ ██║ ╚██████╗╚██████╔╝██║ ╚████║██║ ██║╚██████╔╝ //
1460// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ //
1461// //
1462//==================================================================================================================//
1463// MOTOR CONFIG SECTION //
1464//==================================================================================================================//
1466
1468// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1469// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1470// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1472
1473//--------------------------------------
1474// Motor Configuration Parameters
1475//--------------------------------------
1490#define MOTOR_CONFIG_LIST(X) \
1491 X(MOTOR_TYPE, 0, ) \
1492 X(MOTOR_POLE_PAIRS, 1, ) \
1493 X(MOTOR_DIRECTION, 2, ) \
1494 X(MOTOR_PWM_FREQUENCY, 3, ) \
1495 X(COMMUTATION_MODE, 4, ) \
1496 X(OUTPUT_VOLTAGE_LIMIT, 5, ) \
1497 X(PWM_SWITCHING_SCHEME, 8, ) \
1498 X(IDLE_MOTOR_PWM_BEHAVIOR, 9, )
1499
1500enum class MotorConfig : uint16_t {
1501 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1502 MOTOR_CONFIG_LIST(X)
1503 #undef X
1504};
1505
1506inline const char* to_string(MotorConfig config) {
1507 switch(config) {
1508 #define X(NAME, VALUE, DOC) case MotorConfig::NAME: return #NAME;
1509 MOTOR_CONFIG_LIST(X)
1510 #undef X
1511 default: return "UNKNOWN";
1512 }
1513}
1514
1516// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1517// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1518// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1520
1521//--------------------------------------
1522// Motor Types
1523//--------------------------------------
1535#define MOTOR_TYPE_LIST(X) \
1536 X(NO_MOTOR, 0, ) \
1537 X(DC_MOTOR, 1, ) \
1538 X(STEPPER_MOTOR, 2, ) \
1539 X(BLDC_MOTOR, 3, )
1540
1541enum class MotorType : uint8_t {
1542 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1543 MOTOR_TYPE_LIST(X)
1544 #undef X
1545};
1546
1547inline const char* to_string(MotorType type) {
1548 switch(type) {
1549 #define X(NAME, VALUE, DOC) case MotorType::NAME: return #NAME;
1550 MOTOR_TYPE_LIST(X)
1551 #undef X
1552 default: return "UNKNOWN";
1553 }
1554}
1555#undef MOTOR_TYPE_LIST
1556
1557//--------------------------------------
1558// Motor Direction
1559//--------------------------------------
1569#define MOTOR_DIRECTION_LIST(X) \
1570 X(FORWARD, 0, ) \
1571 X(REVERSE, 1, )
1572
1573enum class MotorDirection : uint8_t {
1574 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1575 MOTOR_DIRECTION_LIST(X)
1576 #undef X
1577};
1578
1579inline const char* to_string(MotorDirection direction) {
1580 switch(direction) {
1581 #define X(NAME, VALUE, DOC) case MotorDirection::NAME: return #NAME;
1582 MOTOR_DIRECTION_LIST(X)
1583 #undef X
1584 default: return "UNKNOWN";
1585 }
1586}
1587#undef MOTOR_DIRECTION_LIST
1588
1589//--------------------------------------
1590// PWM Switching Schemes
1591//--------------------------------------
1602#define PWM_SWITCHING_SCHEME_LIST(X) \
1603 X(STANDARD, 0, ) \
1604 X(SVPWM, 1, ) \
1605 X(FLAT_BOTTOM, 2, )
1606
1607enum class PwmSwitchingScheme : uint8_t {
1608 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1609 PWM_SWITCHING_SCHEME_LIST(X)
1610 #undef X
1611};
1612
1613inline const char* to_string(PwmSwitchingScheme scheme) {
1614 switch(scheme) {
1615 #define X(NAME, VALUE, DOC) case PwmSwitchingScheme::NAME: return #NAME;
1616 PWM_SWITCHING_SCHEME_LIST(X)
1617 #undef X
1618 default: return "UNKNOWN";
1619 }
1620}
1621#undef PWM_SWITCHING_SCHEME_LIST
1622
1625
1695//--------------------------------------
1696// Commutation Modes
1697//--------------------------------------
1715#define COMMUTATION_MODE_LIST(X) \
1716 X(SYSTEM_OFF, 0, ) \
1717 X(SYSTEM_OFF_LOW_SIDE_FETS_ON, 1, ) \
1718 X(SYSTEM_OFF_HIGH_SIDE_FETS_ON,2, ) \
1719 X(FOC_OPENLOOP_VOLTAGE_MODE, 3, ) \
1720 X(FOC_OPENLOOP_CURRENT_MODE, 4, ) \
1721 X(FOC_ABN, 5, ) \
1722 X(FOC_HALL_SENSOR, 6, ) \
1723 X(RESERVED, 7, ) \
1724 X(FOC_SPI_ENC, 8, )
1725
1726enum class CommutationMode : std::uint8_t {
1727 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1728 COMMUTATION_MODE_LIST(X)
1729 #undef X
1730};
1731
1732inline const char* to_string(CommutationMode mode) {
1733 switch(mode) {
1734 #define X(NAME, VALUE, DOC) case CommutationMode::NAME: return #NAME;
1735 COMMUTATION_MODE_LIST(X)
1736 #undef X
1737 default: return "UNKNOWN";
1738 }
1739}
1740#undef COMMUTATION_MODE_LIST
1742
1745//--------------------------------------
1746// Idle Motor PWM Behavior
1747//--------------------------------------
1757#define IDLE_MOTOR_PWM_BEHAVIOR_LIST(X) \
1758 X(PWM_ON_WHEN_MOTOR_IDLE, 0, ) \
1759 X(PWM_OFF_WHEN_MOTOR_IDLE, 1, )
1760
1761enum class IdleMotorPwmBehavior : std::uint8_t {
1762 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1763 IDLE_MOTOR_PWM_BEHAVIOR_LIST(X)
1764 #undef X
1765};
1766
1767inline const char* to_string(IdleMotorPwmBehavior behavior) {
1768 switch(behavior) {
1769 #define X(NAME, VALUE, DOC) case IdleMotorPwmBehavior::NAME: return #NAME;
1770 IDLE_MOTOR_PWM_BEHAVIOR_LIST(X)
1771 #undef X
1772 default: return "UNKNOWN";
1773 }
1774}
1775#undef IDLE_MOTOR_PWM_BEHAVIOR_LIST
1777
1779// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1780// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1781// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1783
1784//--------------------------------------
1785// ADC Configuration Parameters
1786//--------------------------------------
1824#define ADC_CONFIG_LIST(X) \
1825 X(ADC_SHUNT_TYPE, 12, ) \
1826 X(ADC_I0_RAW, 13, ) \
1827 X(ADC_I1_RAW, 14, ) \
1828 X(ADC_I2_RAW, 15, ) \
1829 X(ADC_I3_RAW, 16, ) \
1830 X(CSA_GAIN_ADC_I0_TO_ADC_I2, 17, ) \
1831 X(CSA_GAIN_ADC_I3, 18, ) \
1832 X(CSA_FILTER_ADC_I0_TO_ADC_I2,19, ) \
1833 X(CSA_FILTER_ADC_I3, 20, ) \
1834 X(CURRENT_SCALING_FACTOR, 21, ) \
1835 X(PHASE_UX1_ADC_MAPPING, 22, ) \
1836 X(PHASE_VX2_ADC_MAPPING, 23, ) \
1837 X(PHASE_WY1_ADC_MAPPING, 24, ) \
1838 X(PHASE_Y2_ADC_MAPPING, 25, ) \
1839 X(ADC_I0_SCALE, 26, ) \
1840 X(ADC_I1_SCALE, 27, ) \
1841 X(ADC_I2_SCALE, 28, ) \
1842 X(ADC_I3_SCALE, 29, ) \
1843 X(ADC_I0_INVERTED, 30, ) \
1844 X(ADC_I1_INVERTED, 31, ) \
1845 X(ADC_I2_INVERTED, 32, ) \
1846 X(ADC_I3_INVERTED, 33, ) \
1847 X(ADC_I0_OFFSET, 34, ) \
1848 X(ADC_I1_OFFSET, 35, ) \
1849 X(ADC_I2_OFFSET, 36, ) \
1850 X(ADC_I3_OFFSET, 37, ) \
1851 X(ADC_I0, 38, ) \
1852 X(ADC_I1, 39, ) \
1853 X(ADC_I2, 40, ) \
1854 X(ADC_I3, 41, )
1855
1856enum class AdcConfig : uint16_t {
1857 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1858 ADC_CONFIG_LIST(X)
1859 #undef X
1860};
1861
1862inline const char* to_string(AdcConfig config) {
1863 switch(config) {
1864 #define X(NAME, VALUE, DOC) case AdcConfig::NAME: return #NAME;
1865 ADC_CONFIG_LIST(X)
1866 #undef X
1867 default: return "UNKNOWN";
1868 }
1869}
1870
1872// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1873// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1874// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1876
1877//--------------------------------------
1878// ADC Shunt Types
1879//--------------------------------------
1892#define ADC_SHUNT_TYPE_LIST(X) \
1893 X(INLINE_UVW, 0, ) \
1894 X(INLINE_VW, 1, ) \
1895 X(INLINE_UW, 2, ) \
1896 X(INLINE_UV, 3, ) \
1897 X(BOTTOM_SHUNTS, 4, )
1898
1899enum class AdcShuntType : uint8_t {
1900 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1901 ADC_SHUNT_TYPE_LIST(X)
1902 #undef X
1903};
1904
1905inline const char* to_string(AdcShuntType t) {
1906 switch(t) {
1907 #define X(NAME, VALUE, DOC) case AdcShuntType::NAME: return #NAME;
1908 ADC_SHUNT_TYPE_LIST(X)
1909 #undef X
1910 default: return "UNKNOWN";
1911 }
1912}
1913#undef ADC_SHUNT_TYPE_LIST
1914
1915//--------------------------------------
1916// Current Sense Amplifier Gain
1917//--------------------------------------
1930#define CSA_GAIN_LIST(X) \
1931 X(GAIN_5X, 0, ) \
1932 X(GAIN_10X, 1, ) \
1933 X(GAIN_20X, 2, ) \
1934 X(GAIN_40X, 3, ) \
1935 X(GAIN_1X_BYPASS_CSA, 4, )
1936
1937enum class CsaGain : uint8_t {
1938 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1939 CSA_GAIN_LIST(X)
1940 #undef X
1941};
1942
1943inline const char* to_string(CsaGain g) {
1944 switch(g) {
1945 #define X(NAME, VALUE, DOC) case CsaGain::NAME: return #NAME;
1946 CSA_GAIN_LIST(X)
1947 #undef X
1948 default: return "UNKNOWN";
1949 }
1950}
1951#undef CSA_GAIN_LIST
1952
1953//--------------------------------------
1954// Current Sense Amplifier Filter
1955//--------------------------------------
1967#define CSA_FILTER_LIST(X) \
1968 X(T_0_55_MICROSEC, 0, ) \
1969 X(T_0_75_MICROSEC, 1, ) \
1970 X(T_1_0_MICROSEC, 2, ) \
1971 X(T_1_35_MICROSEC, 3, )
1972
1973enum class CsaFilter : uint8_t {
1974 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1975 CSA_FILTER_LIST(X)
1976 #undef X
1977};
1978
1979inline const char* to_string(CsaFilter f) {
1980 switch(f) {
1981 #define X(NAME, VALUE, DOC) case CsaFilter::NAME: return #NAME;
1982 CSA_FILTER_LIST(X)
1983 #undef X
1984 default: return "UNKNOWN";
1985 }
1986}
1987#undef CSA_FILTER_LIST
1988
1989//--------------------------------------
1990// ADC Mapping
1991//--------------------------------------
2003#define ADC_MAPPING_LIST(X) \
2004 X(ADC_I0, 0, ) \
2005 X(ADC_I1, 1, ) \
2006 X(ADC_I2, 2, ) \
2007 X(ADC_I3, 3, )
2008
2009enum class AdcMapping : uint8_t {
2010 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2011 ADC_MAPPING_LIST(X)
2012 #undef X
2013};
2014
2015inline const char* to_string(AdcMapping m) {
2016 switch(m) {
2017 #define X(NAME, VALUE, DOC) case AdcMapping::NAME: return #NAME;
2018 ADC_MAPPING_LIST(X)
2019 #undef X
2020 default: return "UNKNOWN";
2021 }
2022}
2023#undef ADC_MAPPING_LIST
2024
2025//--------------------------------------
2026// ADC Inversion Settings
2027//--------------------------------------
2037#define ADC_INVERSION_LIST(X) \
2038 X(NOT_INVERTED, 0, ) \
2039 X(INVERTED, 1, )
2040
2041enum class AdcInversion : uint8_t {
2042 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2043 ADC_INVERSION_LIST(X)
2044 #undef X
2045};
2046
2047inline const char* to_string(AdcInversion i) {
2048 switch(i) {
2049 #define X(NAME, VALUE, DOC) case AdcInversion::NAME: return #NAME;
2050 ADC_INVERSION_LIST(X)
2051 #undef X
2052 default: return "UNKNOWN";
2053 }
2054}
2055#undef ADC_INVERSION_LIST
2056
2057//--------------------------------------
2058// PWM Frequency Configuration
2059//--------------------------------------
2072#define PWM_FREQUENCY_LIST(X) \
2073 X(STANDARD_BLDC, 25000, ) \
2074 X(STANDARD_STEPPER, 20000, ) \
2075 X(FAST_BLDC, 50000, ) \
2076 X(ULTRA_FAST_BLDC, 100000, ) \
2077 X(MINIMUM_SILENT, 20001, )
2078
2079enum class PwmFrequency : uint32_t {
2080 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2081 PWM_FREQUENCY_LIST(X)
2082 #undef X
2083};
2084
2085inline const char* to_string(PwmFrequency f) {
2086 switch(f) {
2087 #define X(NAME, VALUE, DOC) case PwmFrequency::NAME: return #NAME;
2088 PWM_FREQUENCY_LIST(X)
2089 #undef X
2090 default: return "UNKNOWN";
2091 }
2092}
2093#undef PWM_FREQUENCY_LIST
2094
2096// //
2097// ███████╗███████╗███████╗██████╗ ██████╗ █████╗ ██████╗██╗ ██╗ //
2098// ██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝██║ ██╔╝ //
2099// █████╗ █████╗ █████╗ ██║ ██║██████╔╝███████║██║ █████╔╝ //
2100// ██╔══╝ ██╔══╝ ██╔══╝ ██║ ██║██╔══██╗██╔══██║██║ ██╔═██╗ //
2101// ██║ ███████╗███████╗██████╔╝██████╔╝██║ ██║╚██████╗██║ ██╗ //
2102// ╚═╝ ╚══════╝╚══════╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝╚═╝ ╚═╝ //
2103// //
2104// ███████╗███████╗███╗ ██╗███████╗ ██████╗ ██████╗ ███████╗ //
2105// ██╔════╝██╔════╝████╗ ██║██╔════╝██╔═══██╗██╔══██╗██╔════╝ //
2106// ███████╗█████╗ ██╔██╗ ██║███████╗██║ ██║██████╔╝███████╗ //
2107// ╚════██║██╔══╝ ██║╚██╗██║╚════██║██║ ██║██╔══██╗╚════██║ //
2108// ███████║███████╗██║ ╚████║███████║╚██████╔╝██║ ██║███████║ //
2109// ╚══════╝╚══════╝╚═╝ ╚═══╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ //
2110// //
2111//==================================================================================================================//
2112// FEEDBACK SENSOR SECTION //
2113//==================================================================================================================//
2115
2117// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2118// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2119// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2121
2122//--------------------------------------
2123// Feedback Sensor Configuration Parameters
2124//--------------------------------------
2181#define FEEDBACK_SENSOR_CONFIG_LIST(X) \
2182 X(ABN_1_PHI_E, 89, ) \
2183 X(ABN_1_STEPS, 90, ) \
2184 X(ABN_1_DIRECTION, 91, ) \
2185 X(ABN_1_INIT_METHOD, 92, ) \
2186 X(ABN_1_INIT_STATE, 93, ) \
2187 X(ABN_1_INIT_DELAY, 94, ) \
2188 X(ABN_1_INIT_VELOCITY, 95, ) \
2189 X(ABN_1_N_CHANNEL_PHI_E_OFFSET, 96, ) \
2190 X(ABN_1_N_CHANNEL_INVERTED, 97, ) \
2191 X(ABN_1_N_CHANNEL_FILTERING, 98, ) \
2192 X(ABN_1_CLEAR_ON_NEXT_NULL, 99, ) \
2193 X(ABN_1_VALUE, 100, ) \
2194 X(HALL_PHI_E, 74, ) \
2195 X(HALL_SECTOR_OFFSET, 75, ) \
2196 X(HALL_FILTER_LENGTH, 76, ) \
2197 X(HALL_POSITION_0_OFFSET, 77, ) \
2198 X(HALL_POSITION_60_OFFSET, 78, ) \
2199 X(HALL_POSITION_120_OFFSET, 79, ) \
2200 X(HALL_POSITION_180_OFFSET, 80, ) \
2201 X(HALL_POSITION_240_OFFSET, 81, ) \
2202 X(HALL_POSITION_300_OFFSET, 82, ) \
2203 X(HALL_INVERT_DIRECTION, 83, ) \
2204 X(HALL_EXTRAPOLATION_ENABLE, 84, ) \
2205 X(HALL_PHI_E_OFFSET, 85, ) \
2206 X(SPI_ENCODER_CS_SETTLE_DELAY_TIME, 181, ) \
2207 X(SPI_ENCODER_CS_IDLE_DELAY_TIME, 182, ) \
2208 X(SPI_ENCODER_MAIN_TRANSFER_CMD_SIZE, 183, ) \
2209 X(SPI_ENCODER_SECONDARY_TRANSFER_CMD_SIZE, 184, ) \
2210 X(SPI_ENCODER_TRANSFER_DATA_3_0, 185, ) \
2211 X(SPI_ENCODER_TRANSFER_DATA_7_4, 186, ) \
2212 X(SPI_ENCODER_TRANSFER_DATA_11_8, 187, ) \
2213 X(SPI_ENCODER_TRANSFER_DATA_15_12, 188, ) \
2214 X(SPI_ENCODER_TRANSFER, 189, ) \
2215 X(SPI_ENCODER_POSITION_COUNTER_MASK, 190, ) \
2216 X(SPI_ENCODER_POSITION_COUNTER_SHIFT, 191, ) \
2217 X(SPI_ENCODER_POSITION_COUNTER_VALUE, 192, ) \
2218 X(SPI_ENCODER_COMMUTATION_ANGLE, 193, ) \
2219 X(SPI_ENCODER_INITIALIZATION_METHOD, 194, ) \
2220 X(SPI_ENCODER_DIRECTION, 195, ) \
2221 X(SPI_ENCODER_OFFSET, 196, ) \
2222 X(SPI_LUT_CORRECTION_ENABLE, 197, ) \
2223 X(SPI_LUT_ADDRESS_SELECT, 198, ) \
2224 X(SPI_LUT_DATA, 199, ) \
2225 X(SPI_LUT_COMMON_SHIFT_FACTOR, 201, ) \
2226 X(ABN_2_STEPS, 174, ) \
2227 X(ABN_2_DIRECTION, 175, ) \
2228 X(ABN_2_GEAR_RATIO, 176, ) \
2229 X(ABN_2_ENABLE, 177, ) \
2230 X(ABN_2_VALUE, 178, )
2231
2232enum class FeedbackSensorConfig : uint16_t {
2233 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2234 FEEDBACK_SENSOR_CONFIG_LIST(X)
2235 #undef X
2236};
2237
2238inline const char* to_string(FeedbackSensorConfig config) {
2239 switch(config) {
2240 #define X(NAME, VALUE, DOC) case FeedbackSensorConfig::NAME: return #NAME;
2241 FEEDBACK_SENSOR_CONFIG_LIST(X)
2242 #undef X
2243 default: return "UNKNOWN";
2244 }
2245}
2246
2248// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2249// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2250// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2252
2253//--------------------------------------
2254// ABN Initialization Methods
2255//--------------------------------------
2267#define ABN_INIT_METHOD_LIST(X) \
2268 X(FORCED_PHI_E_ZERO_WITH_ACTIVE_SWING, 0, ) \
2269 X(FORCED_PHI_E_90_ZERO, 1, ) \
2270 X(USE_HALL, 2, ) \
2271 X(USE_N_CHANNEL_OFFSET, 3, )
2272
2273enum class AbnInitMethod : uint8_t {
2274 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2275 ABN_INIT_METHOD_LIST(X)
2276 #undef X
2277};
2278
2279inline const char* to_string(AbnInitMethod method) {
2280 switch(method) {
2281 #define X(NAME, VALUE, DOC) case AbnInitMethod::NAME: return #NAME;
2282 ABN_INIT_METHOD_LIST(X)
2283 #undef X
2284 default: return "UNKNOWN";
2285 }
2286}
2287#undef ABN_INIT_METHOD_LIST
2288
2289//--------------------------------------
2290// ABN Initialization States
2291//--------------------------------------
2303#define ABN_INIT_STATE_LIST(X) \
2304 X(IDLE, 0, ) \
2305 X(BUSY, 1, ) \
2306 X(WAIT, 2, ) \
2307 X(DONE, 3, )
2308
2309enum class AbnInitState : uint8_t {
2310 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2311 ABN_INIT_STATE_LIST(X)
2312 #undef X
2313};
2314
2315inline const char* to_string(AbnInitState state) {
2316 switch(state) {
2317 #define X(NAME, VALUE, DOC) case AbnInitState::NAME: return #NAME;
2318 ABN_INIT_STATE_LIST(X)
2319 #undef X
2320 default: return "UNKNOWN";
2321 }
2322}
2323#undef ABN_INIT_STATE_LIST
2324
2325//--------------------------------------
2326// ABN N-Channel Filtering Modes
2327//--------------------------------------
2340#define ABN_N_CHANNEL_FILTERING_LIST(X) \
2341 X(FILTERING_OFF, 0, ) \
2342 X(N_EVENT_ON_A_HIGH_B_HIGH, 1, ) \
2343 X(N_EVENT_ON_A_HIGH_B_LOW, 2, ) \
2344 X(N_EVENT_ON_A_LOW_B_HIGH, 3, ) \
2345 X(N_EVENT_ON_A_LOW_B_LOW, 4, )
2346
2347enum class AbnNChannelFiltering : uint8_t {
2348 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2349 ABN_N_CHANNEL_FILTERING_LIST(X)
2350 #undef X
2351};
2352
2353inline const char* to_string(AbnNChannelFiltering filtering) {
2354 switch(filtering) {
2355 #define X(NAME, VALUE, DOC) case AbnNChannelFiltering::NAME: return #NAME;
2356 ABN_N_CHANNEL_FILTERING_LIST(X)
2357 #undef X
2358 default: return "UNKNOWN";
2359 }
2360}
2361#undef ABN_N_CHANNEL_FILTERING_LIST
2362
2363//--------------------------------------
2364// Hall Sector Offsets
2365//--------------------------------------
2379#define HALL_SECTOR_OFFSET_LIST(X) \
2380 X(DEG_0, 0, ) \
2381 X(DEG_60, 1, ) \
2382 X(DEG_120, 2, ) \
2383 X(DEG_180, 3, ) \
2384 X(DEG_240, 4, ) \
2385 X(DEG_300, 5, )
2386
2387enum class HallSectorOffset : uint8_t {
2388 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2389 HALL_SECTOR_OFFSET_LIST(X)
2390 #undef X
2391};
2392
2393inline const char* to_string(HallSectorOffset offset) {
2394 switch(offset) {
2395 #define X(NAME, VALUE, DOC) case HallSectorOffset::NAME: return #NAME;
2396 HALL_SECTOR_OFFSET_LIST(X)
2397 #undef X
2398 default: return "UNKNOWN";
2399 }
2400}
2401#undef HALL_SECTOR_OFFSET_LIST
2402
2403//--------------------------------------
2404// SPI Encoder Transfer Modes
2405//--------------------------------------
2416#define SPI_ENCODER_TRANSFER_LIST(X) \
2417 X(OFF, 0, ) \
2418 X(TRIGGER_SINGLE_TRANSFER, 1, ) \
2419 X(CONTINUOUS_POSITION_COUNTER_READ, 2, )
2420
2421enum class SpiEncoderTransfer : uint8_t {
2422 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2423 SPI_ENCODER_TRANSFER_LIST(X)
2424 #undef X
2425};
2426
2427inline const char* to_string(SpiEncoderTransfer transfer) {
2428 switch(transfer) {
2429 #define X(NAME, VALUE, DOC) case SpiEncoderTransfer::NAME: return #NAME;
2430 SPI_ENCODER_TRANSFER_LIST(X)
2431 #undef X
2432 default: return "UNKNOWN";
2433 }
2434}
2435#undef SPI_ENCODER_TRANSFER_LIST
2436
2437//--------------------------------------
2438// SPI Encoder Initialization Methods
2439//--------------------------------------
2450#define SPI_INIT_METHOD_LIST(X) \
2451 X(FORCED_PHI_E_ZERO_WITH_ACTIVE_SWING, 0, ) \
2452 X(FORCED_PHI_E_90_ZERO, 1, ) \
2453 X(USE_OFFSET, 2, )
2454
2455enum class SpiInitMethod : uint8_t {
2456 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2457 SPI_INIT_METHOD_LIST(X)
2458 #undef X
2459};
2460
2461inline const char* to_string(SpiInitMethod method) {
2462 switch(method) {
2463 #define X(NAME, VALUE, DOC) case SpiInitMethod::NAME: return #NAME;
2464 SPI_INIT_METHOD_LIST(X)
2465 #undef X
2466 default: return "UNKNOWN";
2467 }
2468}
2469#undef SPI_INIT_METHOD_LIST
2470
2471//--------------------------------------
2472// Enable/Disable Settings
2473//--------------------------------------
2483#define ENABLE_DISABLE_LIST(X) \
2484 X(DISABLED, 0, ) \
2485 X(ENABLED, 1, )
2486
2487enum class EnableDisable : uint8_t {
2488 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2489 ENABLE_DISABLE_LIST(X)
2490 #undef X
2491};
2492
2493inline const char* to_string(EnableDisable setting) {
2494 switch(setting) {
2495 #define X(NAME, VALUE, DOC) case EnableDisable::NAME: return #NAME;
2496 ENABLE_DISABLE_LIST(X)
2497 #undef X
2498 default: return "UNKNOWN";
2499 }
2500}
2501#undef ENABLE_DISABLE_LIST
2502
2503//--------------------------------------
2504// Direction Settings
2505//--------------------------------------
2515#define DIRECTION_LIST(X) \
2516 X(NOT_INVERTED, 0, ) \
2517 X(INVERTED, 1, )
2518
2519enum class Direction : uint8_t {
2520 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2521 DIRECTION_LIST(X)
2522 #undef X
2523};
2524
2525inline const char* to_string(Direction direction) {
2526 switch(direction) {
2527 #define X(NAME, VALUE, DOC) case Direction::NAME: return #NAME;
2528 DIRECTION_LIST(X)
2529 #undef X
2530 default: return "UNKNOWN";
2531 }
2532}
2533#undef DIRECTION_LIST
2534
2536// //
2537// ████████╗ ██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗ █████╗ ███╗ ██╗██████╗ //
2538// ╚══██╔══╝██╔═══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝ ██╔══██╗████╗ ██║██╔══██╗ //
2539// ██║ ██║ ██║██████╔╝██║ ██║██║ ██║█████╗ ███████║██╔██╗ ██║██║ ██║ //
2540// ██║ ██║ ██║██╔══██╗██║▄▄ ██║██║ ██║██╔══╝ ██╔══██║██║╚██╗██║██║ ██║ //
2541// ██║ ╚██████╔╝██║ ██║╚██████╔╝╚██████╔╝███████╗ ██║ ██║██║ ╚████║██████╔╝ //
2542// ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚══▀▀═╝ ╚═════╝ ╚══════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ //
2543// //
2544// ███████╗██╗ ██╗ ██╗██╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ ██████╗ ██╗ //
2545// ██╔════╝██║ ██║ ██║╚██╗██╔╝ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔═══██╗██║ //
2546// █████╗ ██║ ██║ ██║ ╚███╔╝ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝██║ ██║██║ //
2547// ██╔══╝ ██║ ██║ ██║ ██╔██╗ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██║ ██║██║ //
2548// ██║ ███████╗╚██████╔╝██╔╝ ██╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║╚██████╔╝███████╗ //
2549// ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝ //
2550// //
2551//==================================================================================================================//
2552// TORQUE AND FLUX CONTROL SECTION //
2553//==================================================================================================================//
2554//==================================================================================================================//
2555
2557// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2558// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2559// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2561
2564//--------------------------------------
2565// Torque and Flux Control Parameters
2566//--------------------------------------
2595#define TORQUE_FLUX_CONTROL_LIST(X) \
2596 X(MAX_TORQUE, 6, ) \
2597 X(MAX_FLUX, 7, ) \
2598 X(TARGET_TORQUE, 104, ) \
2599 X(ACTUAL_TORQUE, 105, ) \
2600 X(TARGET_FLUX, 106, ) \
2601 X(ACTUAL_FLUX, 107, ) \
2602 X(TORQUE_OFFSET, 108, ) \
2603 X(TORQUE_P, 109, ) \
2604 X(TORQUE_I, 110, ) \
2605 X(FLUX_P, 111, ) \
2606 X(FLUX_I, 112, ) \
2607 X(SEPARATE_TORQUE_FLUX_PI_PARAMETERS,113, ) \
2608 X(CURRENT_NORM_P, 114, ) \
2609 X(CURRENT_NORM_I, 115, ) \
2610 X(TORQUE_PI_ERROR, 116, ) \
2611 X(FLUX_PI_ERROR, 117, ) \
2612 X(TORQUE_PI_INTEGRATOR, 118, ) \
2613 X(FLUX_PI_INTEGRATOR, 119, ) \
2614 X(FLUX_OFFSET, 120, ) \
2615 X(FIELDWEAKENING_I, 308, ) \
2616 X(FIELDWEAKENING_VOLTAGE_THRESHOLD, 310, )
2617
2618enum class TorqueFluxControl : uint16_t {
2619 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2620 TORQUE_FLUX_CONTROL_LIST(X)
2621 #undef X
2622};
2623
2624inline const char* to_string(TorqueFluxControl config) {
2625 switch(config) {
2626 #define X(NAME, VALUE, DOC) case TorqueFluxControl::NAME: return #NAME;
2627 TORQUE_FLUX_CONTROL_LIST(X)
2628 #undef X
2629 default: return "UNKNOWN";
2630 }
2631}
2633
2635// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2636// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2637// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2639
2642//--------------------------------------
2643// Torque/Flux PI Separation
2644//--------------------------------------
2654#define TORQUE_FLUX_PI_SEPARATION_LIST(X) \
2655 X(TORQUE_FLUX_PI_COMBINED, 0, ) \
2656 X(TORQUE_FLUX_PI_SEPARATED, 1, )
2657
2658enum class TorqueFluxPiSeparation : uint8_t {
2659 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2660 TORQUE_FLUX_PI_SEPARATION_LIST(X)
2661 #undef X
2662};
2663
2664inline const char* to_string(TorqueFluxPiSeparation separation) {
2665 switch(separation) {
2666 #define X(NAME, VALUE, DOC) case TorqueFluxPiSeparation::NAME: return #NAME;
2667 TORQUE_FLUX_PI_SEPARATION_LIST(X)
2668 #undef X
2669 default: return "UNKNOWN";
2670 }
2671}
2672#undef TORQUE_FLUX_PI_SEPARATION_LIST
2674
2677//--------------------------------------
2678// Current PI Normalization Format
2679//--------------------------------------
2689#define CURRENT_PI_NORMALIZATION_LIST(X) \
2690 X(SHIFT_8_BIT, 0, ) \
2691 X(SHIFT_16_BIT, 1, )
2692
2693enum class CurrentPiNormalization : uint8_t {
2694 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2695 CURRENT_PI_NORMALIZATION_LIST(X)
2696 #undef X
2697};
2698
2699inline const char* to_string(CurrentPiNormalization norm) {
2700 switch(norm) {
2701 #define X(NAME, VALUE, DOC) case CurrentPiNormalization::NAME: return #NAME;
2702 CURRENT_PI_NORMALIZATION_LIST(X)
2703 #undef X
2704 default: return "UNKNOWN";
2705 }
2706}
2707#undef CURRENT_PI_NORMALIZATION_LIST
2709
2711// //
2712// ██╗ ██╗███████╗██╗ ██████╗ ██████╗██╗████████╗██╗ ██╗ ███╗ ███╗ ██████╗ ██████╗ ███████╗ //
2713// ██║ ██║██╔════╝██║ ██╔═══██╗██╔════╝██║╚══██╔══╝╚██╗ ██╔╝ ████╗ ████║██╔═══██╗██╔══██╗██╔════╝ //
2714// ██║ ██║█████╗ ██║ ██║ ██║██║ ██║ ██║ ╚████╔╝ ██╔████╔██║██║ ██║██║ ██║█████╗ //
2715// ╚██╗ ██╔╝██╔══╝ ██║ ██║ ██║██║ ██║ ██║ ╚██╔╝ ██║╚██╔╝██║██║ ██║██║ ██║██╔══╝ //
2716// ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╗██║ ██║ ██║ ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗ //
2717// ╚═══╝ ╚══════╝╚══════╝ ╚═════╝ ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ //
2718// //
2719//==================================================================================================================//
2720// VELOCITY MODE SECTION //
2721//==================================================================================================================//
2723
2725// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2726// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2727// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2729
2732//--------------------------------------
2733// Velocity Control Parameters
2734//--------------------------------------
2781#define VELOCITY_CONTROL_LIST(X) \
2782 X(VELOCITY_SENSOR_SELECTION, 123, ) \
2783 X(TARGET_VELOCITY, 124, ) \
2784 X(ACTUAL_VELOCITY, 125, ) \
2785 X(VELOCITY_OFFSET, 126, ) \
2786 X(VELOCITY_P, 127, ) \
2787 X(VELOCITY_I, 128, ) \
2788 X(VELOCITY_NORM_P, 129, ) \
2789 X(VELOCITY_NORM_I, 130, ) \
2790 X(VELOCITY_PI_INTEGRATOR, 131, ) \
2791 X(VELOCITY_PI_ERROR, 132, ) \
2792 X(VELOCITY_SCALING_FACTOR, 133, ) \
2793 X(VELOCITY_LOOP_DOWNSAMPLING, 135, ) \
2794 X(VELOCITY_METER_SWITCH_THRESHOLD, 137, ) \
2795 X(VELOCITY_METER_SWITCH_HYSTERESIS, 138, ) \
2796 X(VELOCITY_METER_MODE, 139, ) \
2797 X(OPENLOOP_ANGLE, 45, ) \
2798 X(OPENLOOP_CURRENT, 46, ) \
2799 X(OPENLOOP_VOLTAGE, 47, ) \
2800 X(ACCELERATION_FF_GAIN, 50, ) \
2801 X(ACCELERATION_FF_SHIFT, 51, ) \
2802 X(RAMP_ENABLE, 52, ) \
2803 X(DIRECT_VELOCITY_MODE, 53, ) \
2804 X(RAMP_AMAX, 54, ) \
2805 X(RAMP_A1, 55, ) \
2806 X(RAMP_A2, 56, ) \
2807 X(RAMP_DMAX, 57, ) \
2808 X(RAMP_D1, 58, ) \
2809 X(RAMP_D2, 59, ) \
2810 X(RAMP_VMAX, 60, ) \
2811 X(RAMP_V1, 61, ) \
2812 X(RAMP_V2, 62, ) \
2813 X(RAMP_VSTART, 63, ) \
2814 X(RAMP_VSTOP, 64, ) \
2815 X(RAMP_TVMAX, 65, ) \
2816 X(RAMP_TZEROWAIT, 66, ) \
2817 X(ACCELERATION_FEEDFORWARD_ENABLE, 67, ) \
2818 X(VELOCITY_FEEDFORWARD_ENABLE, 68, ) \
2819 X(RAMP_VELOCITY, 69, ) \
2820 X(RAMP_POSITION, 70, ) \
2821
2822enum class VelocityControl : uint16_t {
2823 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2824 VELOCITY_CONTROL_LIST(X)
2825 #undef X
2826};
2827
2828inline const char* to_string(VelocityControl config) {
2829 switch(config) {
2830 #define X(NAME, VALUE, DOC) case VelocityControl::NAME: return #NAME;
2831 VELOCITY_CONTROL_LIST(X)
2832 #undef X
2833 default: return "UNKNOWN";
2834 }
2835}
2837
2839// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2840// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2841// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2843
2846//--------------------------------------
2847// Velocity Sensor Selection
2848//--------------------------------------
2861#define VELOCITY_SENSOR_SELECTION_LIST(X) \
2862 X(SAME_AS_COMMUTATION, 0, ) \
2863 X(DIGITAL_HALL, 1, ) \
2864 X(ABN1_ENCODER, 2, ) \
2865 X(ABN2_ENCODER, 3, ) \
2866 X(SPI_ENCODER, 4, )
2867
2868enum class VelocitySensorSelection : uint8_t {
2869 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2870 VELOCITY_SENSOR_SELECTION_LIST(X)
2871 #undef X
2872};
2873
2874inline const char* to_string(VelocitySensorSelection selection) {
2875 switch(selection) {
2876 #define X(NAME, VALUE, DOC) case VelocitySensorSelection::NAME: return #NAME;
2877 VELOCITY_SENSOR_SELECTION_LIST(X)
2878 #undef X
2879 default: return "UNKNOWN";
2880 }
2881}
2882#undef VELOCITY_SENSOR_SELECTION_LIST
2884
2887//--------------------------------------
2888// Velocity PI Normalization
2889//--------------------------------------
2901#define VELOCITY_PI_NORM_LIST(X) \
2902 X(NO_SHIFT, 0, ) \
2903 X(SHIFT_8_BIT, 1, ) \
2904 X(SHIFT_16_BIT,2, ) \
2905 X(SHIFT_24_BIT,3, )
2906
2907enum class VelocityPiNorm : uint8_t {
2908 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2909 VELOCITY_PI_NORM_LIST(X)
2910 #undef X
2911};
2912
2913inline const char* to_string(VelocityPiNorm norm) {
2914 switch(norm) {
2915 #define X(NAME, VALUE, DOC) case VelocityPiNorm::NAME: return #NAME;
2916 VELOCITY_PI_NORM_LIST(X)
2917 #undef X
2918 default: return "UNKNOWN";
2919 }
2920}
2921#undef VELOCITY_PI_NORM_LIST
2923
2926//--------------------------------------
2927// Velocity Meter Modes
2928//--------------------------------------
2939#define VELOCITY_METER_MODE_LIST(X) \
2940 X(PERIOD_METER, 0, ) \
2941 X(FREQUENCY_METER, 1, ) \
2942 X(SOFTWARE_METER, 2, )
2943
2944enum class VelocityMeterMode : std::uint8_t {
2945 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2946 VELOCITY_METER_MODE_LIST(X)
2947 #undef X
2948};
2949
2950inline const char* to_string(VelocityMeterMode mode) {
2951 switch(mode) {
2952 #define X(NAME, VALUE, DOC) case VelocityMeterMode::NAME: return #NAME;
2953 VELOCITY_METER_MODE_LIST(X)
2954 #undef X
2955 default: return "UNKNOWN";
2956 }
2957}
2958#undef VELOCITY_METER_MODE_LIST
2960
2963//--------------------------------------
2964// Acceleration Feedforward Shift
2965//--------------------------------------
2980#define ACCELERATION_FF_SHIFT_LIST(X) \
2981 X(NO_SHIFT, 0, ) \
2982 X(SHIFT_4_BIT, 1, ) \
2983 X(SHIFT_8_BIT, 2, ) \
2984 X(SHIFT_12_BIT, 3, ) \
2985 X(SHIFT_16_BIT, 4, ) \
2986 X(SHIFT_20_BIT, 5, ) \
2987 X(SHIFT_24_BIT, 6, )
2988
2989enum class AccelerationFFShift : uint8_t {
2990 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2991 ACCELERATION_FF_SHIFT_LIST(X)
2992 #undef X
2993};
2994
2995inline const char* to_string(AccelerationFFShift shift) {
2996 switch(shift) {
2997 #define X(NAME, VALUE, DOC) case AccelerationFFShift::NAME: return #NAME;
2998 ACCELERATION_FF_SHIFT_LIST(X)
2999 #undef X
3000 default: return "UNKNOWN";
3001 }
3002}
3003#undef ACCELERATION_FF_SHIFT_LIST
3005
3007// //
3008// ██████╗ ██████╗ ███████╗██╗████████╗██╗ ██████╗ ███╗ ██╗ ███╗ ███╗ ██████╗ ██████╗ ███████╗ //
3009// ██╔══██╗██╔═══██╗██╔════╝██║╚══██╔══╝██║██╔═══██╗████╗ ██║ ████╗ ████║██╔═══██╗██╔══██╗██╔════╝ //
3010// ██████╔╝██║ ██║███████╗██║ ██║ ██║██║ ██║██╔██╗ ██║ ██╔████╔██║██║ ██║██║ ██║█████╗ //
3011// ██╔═══╝ ██║ ██║╚════██║██║ ██║ ██║██║ ██║██║╚██╗██║ ██║╚██╔╝██║██║ ██║██║ ██║██╔══╝ //
3012// ██║ ╚██████╔╝███████║██║ ██║ ██║╚██████╔╝██║ ╚████║ ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗ //
3013// ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ //
3014// //
3015//==================================================================================================================//
3016// POSITION MODE SECTION //
3017//==================================================================================================================//
3019
3021// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3022// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3023// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3025
3028//--------------------------------------
3029// Position Control Parameters
3030//--------------------------------------
3053#define POSITION_CONTROL_LIST(X) \
3054 X(POSITION_SENSOR_SELECTION, 142, ) \
3055 X(TARGET_POSITION, 143, ) \
3056 X(ACTUAL_POSITION, 144, ) \
3057 X(POSITION_SCALING_FACTOR, 145, ) \
3058 X(POSITION_P, 146, ) \
3059 X(POSITION_I, 147, ) \
3060 X(POSITION_NORM_P, 148, ) \
3061 X(POSITION_NORM_I, 149, ) \
3062 X(POSITION_PI_INTEGRATOR, 150, ) \
3063 X(POSITION_PI_ERROR, 151, ) \
3064 X(POSITION_LOOP_DOWNSAMPLING,153, ) \
3065 X(LATCH_POSITION, 154, ) \
3066 X(POSITION_LIMIT_LOW, 155, ) \
3067 X(POSITION_LIMIT_HIGH, 156, ) \
3068 X(POSITION_REACHED_THRESHOLD,157, )
3069
3070enum class PositionControl : uint16_t {
3071 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3072 POSITION_CONTROL_LIST(X)
3073 #undef X
3074};
3075
3076inline const char* to_string(PositionControl config) {
3077 switch(config) {
3078 #define X(NAME, VALUE, DOC) case PositionControl::NAME: return #NAME;
3079 POSITION_CONTROL_LIST(X)
3080 #undef X
3081 default: return "UNKNOWN";
3082 }
3083}
3085
3087// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3088// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3089// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3091
3094//--------------------------------------
3095// Position Sensor Selection
3096//--------------------------------------
3109#define POSITION_SENSOR_SELECTION_LIST(X) \
3110 X(SAME_AS_COMMUTATION, 0, ) \
3111 X(DIGITAL_HALL, 1, ) \
3112 X(ABN1_ENCODER, 2, ) \
3113 X(ABN2_ENCODER, 3, ) \
3114 X(SPI_ENCODER, 4, )
3115
3116enum class PositionSensorSelection : uint8_t {
3117 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3118 POSITION_SENSOR_SELECTION_LIST(X)
3119 #undef X
3120};
3121
3122inline const char* to_string(PositionSensorSelection selection) {
3123 switch(selection) {
3124 #define X(NAME, VALUE, DOC) case PositionSensorSelection::NAME: return #NAME;
3125 POSITION_SENSOR_SELECTION_LIST(X)
3126 #undef X
3127 default: return "UNKNOWN";
3128 }
3129}
3130#undef POSITION_SENSOR_SELECTION_LIST
3132
3135//--------------------------------------
3136// Position PI Normalization
3137//--------------------------------------
3149#define POSITION_PI_NORM_LIST(X) \
3150 X(NO_SHIFT, 0, ) \
3151 X(SHIFT_8_BIT, 1, ) \
3152 X(SHIFT_16_BIT, 2, ) \
3153 X(SHIFT_24_BIT, 3, )
3154
3155enum class PositionPiNorm : uint8_t {
3156 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3157 POSITION_PI_NORM_LIST(X)
3158 #undef X
3159};
3160
3161inline const char* to_string(PositionPiNorm norm) {
3162 switch(norm) {
3163 #define X(NAME, VALUE, DOC) case PositionPiNorm::NAME: return #NAME;
3164 POSITION_PI_NORM_LIST(X)
3165 #undef X
3166 default: return "UNKNOWN";
3167 }
3168}
3169#undef POSITION_PI_NORM_LIST
3171
3173// //
3174// ██████╗ █████╗ ███╗ ███╗██████╗ ███████╗██████╗ ███████╗████████╗ ██████╗ ██████╗ //
3175// ██╔══██╗██╔══██╗████╗ ████║██╔══██╗██╔════╝██╔══██╗ ██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗ //
3176// ██████╔╝███████║██╔████╔██║██████╔╝█████╗ ██████╔╝ ███████╗ ██║ ██║ ██║██████╔╝ //
3177// ██╔══██╗██╔══██║██║╚██╔╝██║██╔═══╝ ██╔══╝ ██╔══██╗ ╚════██║ ██║ ██║ ██║██╔═══╝ //
3178// ██║ ██║██║ ██║██║ ╚═╝ ██║██║ ███████╗██║ ██║ ███████║ ██║ ╚██████╔╝██║ //
3179// ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═╝ ╚══════╝ ╚═╝ ╚═════╝ ╚═╝ //
3180// //
3181// ██████╗ ██████╗ ███╗ ██╗██████╗ ██╗████████╗██╗ ██████╗ ███╗ ██╗███████╗ ██╗ //
3182// ██╔════╝██╔═══██╗████╗ ██║██╔══██╗██║╚══██╔══╝██║██╔═══██╗████╗ ██║██╔════╝ ██╔╝ //
3183// ██║ ██║ ██║██╔██╗ ██║██║ ██║██║ ██║ ██║██║ ██║██╔██╗ ██║███████╗ ██╔╝ //
3184// ██║ ██║ ██║██║╚██╗██║██║ ██║██║ ██║ ██║██║ ██║██║╚██╗██║╚════██║ ██╔╝ //
3185// ╚██████╗╚██████╔╝██║ ╚████║██████╔╝██║ ██║ ██║╚██████╔╝██║ ╚████║███████║ ██╔╝ //
3186// ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ ╚═╝ //
3187// //
3188// ██████╗ ███████╗███████╗███████╗██████╗ ███████╗███╗ ██╗ ██████╗███████╗ //
3189// ██╔══██╗██╔════╝██╔════╝██╔════╝██╔══██╗██╔════╝████╗ ██║██╔════╝██╔════╝ //
3190// ██████╔╝█████╗ █████╗ █████╗ ██████╔╝█████╗ ██╔██╗ ██║██║ █████╗ //
3191// ██╔══██╗██╔══╝ ██╔══╝ ██╔══╝ ██╔══██╗██╔══╝ ██║╚██╗██║██║ ██╔══╝ //
3192// ██║ ██║███████╗██║ ███████╗██║ ██║███████╗██║ ╚████║╚██████╗███████╗ //
3193// ╚═╝ ╚═╝╚══════╝╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝ ╚═════╝╚══════╝ //
3194// //
3195// ███████╗██╗ ██╗██╗████████╗ ██████╗██╗ ██╗███████╗███████╗ //
3196// ██╔════╝██║ ██║██║╚══██╔══╝██╔════╝██║ ██║██╔════╝██╔════╝ //
3197// ███████╗██║ █╗ ██║██║ ██║ ██║ ███████║█████╗ ███████╗ //
3198// ╚════██║██║███╗██║██║ ██║ ██║ ██╔══██║██╔══╝ ╚════██║ //
3199// ███████║╚███╔███╔╝██║ ██║ ╚██████╗██║ ██║███████╗███████║ //
3200// ╚══════╝ ╚══╝╚══╝ ╚═╝ ╚═╝ ╚═════╝╚═╝ ╚═╝╚══════╝╚══════╝ //
3201// //
3202//==================================================================================================================//
3203// RAMPER STOP CONDITIONS AND REFERENCE SWITCHES //
3204//==================================================================================================================//
3206
3208// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3209// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3210// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3212
3215//--------------------------------------
3216// Ramper Stop Conditions and Reference Switches
3217//--------------------------------------
3232#define RAMPER_STOP_CONFIG_LIST(X) \
3233 X(STOP_ON_VELOCITY_DEVIATION, 134, ) \
3234 X(STOP_ON_POSITION_DEVIATION, 152, ) \
3235 /* LATCH_POSITION handled in POSITION_CONTROL_LIST */ \
3236 X(REFERENCE_SWITCH_ENABLE, 161, ) \
3237 X(REFERENCE_SWITCH_POLARITY_AND_SWAP,162, ) \
3238 X(REFERENCE_SWITCH_LATCH_SETTINGS, 163, ) \
3239 X(EVENT_STOP_SETTINGS, 164, )
3240
3241enum class RamperStopConfig : uint16_t {
3242 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3243 RAMPER_STOP_CONFIG_LIST(X)
3244 #undef X
3245};
3246
3247inline const char* to_string(RamperStopConfig config) {
3248 switch(config) {
3249 #define X(NAME, VALUE, DOC) case RamperStopConfig::NAME: return #NAME;
3250 RAMPER_STOP_CONFIG_LIST(X)
3251 #undef X
3252 default: return "UNKNOWN";
3253 }
3254}
3256
3258// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3259// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3260// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3262
3265//--------------------------------------
3266// Reference Switch Enable
3267//--------------------------------------
3283#define REFERENCE_SWITCH_ENABLE_LIST(X) \
3284 X(NO_STOP_ON_SWITCH_TRIGGERED, 0, ) \
3285 X(STOP_ON_L, 1, ) \
3286 X(STOP_ON_R, 2, ) \
3287 X(STOP_ON_R_AND_L, 3, ) \
3288 X(STOP_ON_H, 4, ) \
3289 X(STOP_ON_H_AND_L, 5, ) \
3290 X(STOP_ON_H_AND_R, 6, ) \
3291 X(STOP_ON_H_R_AND_L, 7, )
3292
3293enum class ReferenceSwitchEnable : uint8_t {
3294 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3295 REFERENCE_SWITCH_ENABLE_LIST(X)
3296 #undef X
3297};
3298
3299inline const char* to_string(ReferenceSwitchEnable enable) {
3300 switch(enable) {
3301 #define X(NAME, VALUE, DOC) case ReferenceSwitchEnable::NAME: return #NAME;
3302 REFERENCE_SWITCH_ENABLE_LIST(X)
3303 #undef X
3304 default: return "UNKNOWN";
3305 }
3306}
3307#undef REFERENCE_SWITCH_ENABLE_LIST
3309
3312//--------------------------------------
3313// Reference Switch Polarity and Swap
3314//--------------------------------------
3338#define REFERENCE_SWITCH_POLARITY_SWAP_LIST(X) \
3339 X(NOT_SWAPPED_NOT_INVERTED, 0, ) \
3340 X(L_INVERTED, 1, ) \
3341 X(R_INVERTED, 2, ) \
3342 X(R_AND_L_INVERTED, 3, ) \
3343 X(H_INVERTED, 4, ) \
3344 X(H_AND_L_INVERTED, 5, ) \
3345 X(H_AND_R_INVERTED, 6, ) \
3346 X(H_R_AND_L_INVERTED, 7, ) \
3347 X(L_R_SWAPPED_L_INVERTED, 8, ) \
3348 X(L_R_SWAPPED_R_INVERTED, 9, ) \
3349 X(L_R_SWAPPED_R_AND_L_INVERTED, 10, ) \
3350 X(L_R_SWAPPED_H_INVERTED, 11, ) \
3351 X(L_R_SWAPPED_H_AND_L_INVERTED, 12, ) \
3352 X(L_R_SWAPPED, 13, ) \
3353 X(L_R_SWAPPED_H_AND_R_INVERTED, 14, ) \
3354 X(L_R_SWAPPED_H_R_AND_L_INVERTED,15, )
3355
3356enum class ReferenceSwitchPolaritySwap : uint8_t {
3357 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3358 REFERENCE_SWITCH_POLARITY_SWAP_LIST(X)
3359 #undef X
3360};
3361
3362inline const char* to_string(ReferenceSwitchPolaritySwap config) {
3363 switch(config) {
3364 #define X(NAME, VALUE, DOC) case ReferenceSwitchPolaritySwap::NAME: return #NAME;
3365 REFERENCE_SWITCH_POLARITY_SWAP_LIST(X)
3366 #undef X
3367 default: return "UNKNOWN";
3368 }
3369}
3370#undef REFERENCE_SWITCH_POLARITY_SWAP_LIST
3372
3375//--------------------------------------
3376// Reference Switch Latch Settings
3377//--------------------------------------
3401#define REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X) \
3402 X(NO_TRIGGER, 0, ) \
3403 X(L_R_RISING_EDGE, 1, ) \
3404 X(L_R_FALLING_EDGE, 2, ) \
3405 X(L_R_BOTH_EDGES, 3, ) \
3406 X(H_RISING_EDGE, 4, ) \
3407 X(H_L_R_RISING_EDGE, 5, ) \
3408 X(H_RISING_L_R_FALLING_EDGE, 6, ) \
3409 X(H_RISING_L_R_BOTH_EDGES, 7, ) \
3410 X(H_FALLING_EDGE, 8, ) \
3411 X(H_FALLING_L_R_RISING_EDGE, 9, ) \
3412 X(H_L_R_FALLING_EDGE, 10, ) \
3413 X(H_FALLING_L_R_BOTH_EDGES, 11, ) \
3414 X(H_BOTH_EDGES, 12, ) \
3415 X(H_BOTH_L_R_RISING_EDGE, 13, ) \
3416 X(H_BOTH_L_R_FALLING_EDGE, 14, ) \
3417 X(H_L_R_BOTH_EDGES, 15, )
3418
3419enum class ReferenceSwitchLatchSettings : uint8_t {
3420 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3421 REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X)
3422 #undef X
3423};
3424
3425inline const char* to_string(ReferenceSwitchLatchSettings setting) {
3426 switch(setting) {
3427 #define X(NAME, VALUE, DOC) case ReferenceSwitchLatchSettings::NAME: return #NAME;
3428 REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X)
3429 #undef X
3430 default: return "UNKNOWN";
3431 }
3432}
3433#undef REFERENCE_SWITCH_LATCH_SETTINGS_LIST
3435
3438//--------------------------------------
3439// Event Stop Settings
3440//--------------------------------------
3456#define EVENT_STOP_SETTINGS_LIST(X) \
3457 X(DO_HARD_STOP, 0, ) \
3458 X(DO_SOFT_STOP, 1, ) \
3459 X(STOP_ON_POS_DEVIATION, 2, ) \
3460 X(STOP_ON_POS_DEVIATION_SOFT_STOP, 3, ) \
3461 X(STOP_ON_VEL_DEVIATION, 4, ) \
3462 X(STOP_ON_VEL_DEVIATION_SOFT_STOP, 5, ) \
3463 X(STOP_ON_POS_VEL_DEVIATION, 6, ) \
3464 X(STOP_ON_POS_VEL_DEVIATION_SOFT_STOP, 7, )
3465
3466enum class EventStopSettings : uint8_t {
3467 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3468 EVENT_STOP_SETTINGS_LIST(X)
3469 #undef X
3470};
3471
3472inline const char* to_string(EventStopSettings setting) {
3473 switch(setting) {
3474 #define X(NAME, VALUE, DOC) case EventStopSettings::NAME: return #NAME;
3475 EVENT_STOP_SETTINGS_LIST(X)
3476 #undef X
3477 default: return "UNKNOWN";
3478 }
3479}
3480#undef EVENT_STOP_SETTINGS_LIST
3482
3484// //
3485// ██████╗ ██╗ ██████╗ ██╗ ██╗ █████╗ ██████╗ ███████╗██╗██╗ ████████╗███████╗██████╗ //
3486// ██╔══██╗██║██╔═══██╗██║ ██║██╔══██╗██╔══██╗ ██╔════╝██║██║ ╚══██╔══╝██╔════╝██╔══██╗ //
3487// ██████╔╝██║██║ ██║██║ ██║███████║██║ ██║ █████╗ ██║██║ ██║ █████╗ ██████╔╝ //
3488// ██╔══██╗██║██║▄▄ ██║██║ ██║██╔══██║██║ ██║ ██╔══╝ ██║██║ ██║ ██╔══╝ ██╔══██╗ //
3489// ██████╔╝██║╚██████╔╝╚██████╔╝██║ ██║██████╔╝ ██║ ██║███████╗██║ ███████╗██║ ██║ //
3490// ╚═════╝ ╚═╝ ╚══▀▀═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚══════╝╚═╝ ╚═╝ //
3491// //
3492//==================================================================================================================//
3493// BIQUAD FILTER SETUP SECTION //
3494//==================================================================================================================//
3496
3498// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3499// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3500// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3502
3505//--------------------------------------
3506// Biquad Filter Parameters
3507//--------------------------------------
3540#define BIQUAD_FILTER_LIST(X) \
3541 X(TARGET_TORQUE_BIQUAD_FILTER_ENABLE, 318, ) \
3542 X(TARGET_TORQUE_BIQUAD_FILTER_ACOEFF_1, 319, ) \
3543 X(TARGET_TORQUE_BIQUAD_FILTER_ACOEFF_2, 320, ) \
3544 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_0, 321, ) \
3545 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_1, 322, ) \
3546 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_2, 323, ) \
3547 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ENABLE, 324, ) \
3548 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ACOEFF_1, 325, ) \
3549 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ACOEFF_2, 326, ) \
3550 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_0, 327, ) \
3551 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_1, 328, ) \
3552 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_2, 329, )
3553
3554enum class BiquadFilter : uint16_t {
3555 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3556 BIQUAD_FILTER_LIST(X)
3557 #undef X
3558};
3559
3560inline const char* to_string(BiquadFilter e) {
3561 switch(e) {
3562 #define X(NAME, VALUE, DOC) case BiquadFilter::NAME: return #NAME;
3563 BIQUAD_FILTER_LIST(X)
3564 #undef X
3565 default: return "UNKNOWN";
3566 }
3567}
3569
3571// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3572// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3573// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3575
3578//--------------------------------------
3579// Biquad Filter Enable/Disable
3580//--------------------------------------
3590#define BIQUAD_FILTER_ENABLE_LIST(X) \
3591 X(DISABLED, 0, ) \
3592 X(ENABLED, 1, )
3593
3594enum class BiquadFilterEnable : uint8_t {
3595 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3596 BIQUAD_FILTER_ENABLE_LIST(X)
3597 #undef X
3598};
3599
3600inline const char* to_string(BiquadFilterEnable enable) {
3601 switch(enable) {
3602 #define X(NAME, VALUE, DOC) case BiquadFilterEnable::NAME: return #NAME;
3603 BIQUAD_FILTER_ENABLE_LIST(X)
3604 #undef X
3605 default: return "UNKNOWN";
3606 }
3607}
3608#undef BIQUAD_FILTER_ENABLE_LIST
3610
3612// //
3613// ███████╗ █████╗ ██╗ ██╗██╗ ████████╗ ██╗ ██╗ █████╗ ███╗ ██╗██████╗ ██╗ ██╗███╗ ██╗ ██████╗ //
3614// ██╔════╝██╔══██╗██║ ██║██║ ╚══██╔══╝ ██║ ██║██╔══██╗████╗ ██║██╔══██╗██║ ██║████╗ ██║██╔════╝ //
3615// █████╗ ███████║██║ ██║██║ ██║ ███████║███████║██╔██╗ ██║██║ ██║██║ ██║██╔██╗ ██║██║ ███╗ //
3616// ██╔══╝ ██╔══██║██║ ██║██║ ██║ ██╔══██║██╔══██║██║╚██╗██║██║ ██║██║ ██║██║╚██╗██║██║ ██║ //
3617// ██║ ██║ ██║╚██████╔╝███████╗██║ ██║ ██║██║ ██║██║ ╚████║██████╔╝███████╗██║██║ ╚████║╚██████╔╝ //
3618// ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ╚══════╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
3619// //
3620//==================================================================================================================//
3621// FAULT HANDLING SECTION //
3622//==================================================================================================================//
3624
3626// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3627// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3628// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3630
3633//--------------------------------------
3634// Fault Handling Parameters
3635//--------------------------------------
3651#define FAULT_HANDLING_LIST(X) \
3652 X(GDRV_RETRY_BEHAVIOUR, 286, ) \
3653 X(DRIVE_FAULT_BEHAVIOUR, 287, ) \
3654 X(FAULT_HANDLER_NUMBER_OF_RETRIES, 288, )
3655
3656enum class FaultHandling : uint16_t {
3657 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3658 FAULT_HANDLING_LIST(X)
3659 #undef X
3660};
3661
3662inline const char* to_string(FaultHandling config) {
3663 switch(config) {
3664 #define X(NAME, VALUE, DOC) case FaultHandling::NAME: return #NAME;
3665 FAULT_HANDLING_LIST(X)
3666 #undef X
3667 default: return "UNKNOWN";
3668 }
3669}
3671
3673// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3674// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3675// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3677
3680//--------------------------------------
3681// Gate Driver Retry Behaviour
3682//--------------------------------------
3692#define GDRV_RETRY_BEHAVIOUR_LIST(X) \
3693 X(OPEN_CIRCUIT, 0, ) \
3694 X(ELECTRICAL_BRAKING, 1, )
3695
3696enum class GdrvRetryBehaviour : uint8_t {
3697 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3698 GDRV_RETRY_BEHAVIOUR_LIST(X)
3699 #undef X
3700};
3701
3702inline const char* to_string(GdrvRetryBehaviour behaviour) {
3703 switch(behaviour) {
3704 #define X(NAME, VALUE, DOC) case GdrvRetryBehaviour::NAME: return #NAME;
3705 GDRV_RETRY_BEHAVIOUR_LIST(X)
3706 #undef X
3707 default: return "UNKNOWN";
3708 }
3709}
3710#undef GDRV_RETRY_BEHAVIOUR_LIST
3712
3715//--------------------------------------
3716// Drive Fault Behaviour
3717//--------------------------------------
3729#define DRIVE_FAULT_BEHAVIOUR_LIST(X) \
3730 X(OPEN_CIRCUIT, 0, ) \
3731 X(ELECTRICAL_BRAKING, 1, ) \
3732 X(MECHANICAL_BRAKING_AND_OPEN_CIRCUIT,2, ) \
3733 X(MECHANICAL_AND_ELECTRICAL_BRAKING, 3, )
3734
3735enum class DriveFaultBehaviour : std::uint8_t {
3736 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3737 DRIVE_FAULT_BEHAVIOUR_LIST(X)
3738 #undef X
3739};
3740
3741inline const char* to_string(DriveFaultBehaviour behaviour) {
3742 switch(behaviour) {
3743 #define X(NAME, VALUE, DOC) case DriveFaultBehaviour::NAME: return #NAME;
3744 DRIVE_FAULT_BEHAVIOUR_LIST(X)
3745 #undef X
3746 default: return "UNKNOWN";
3747 }
3748}
3749#undef DRIVE_FAULT_BEHAVIOUR_LIST
3751
3753// //
3754// ██╗██╗████████╗ ███╗ ███╗ ██████╗ ███╗ ██╗██╗████████╗ ██████╗ ██████╗ //
3755// ██║██║╚══██╔══╝ ████╗ ████║██╔═══██╗████╗ ██║██║╚══██╔══╝██╔═══██╗██╔══██╗ //
3756// ██║██║ ██║ ██╔████╔██║██║ ██║██╔██╗ ██║██║ ██║ ██║ ██║██████╔╝ //
3757// ██║██║ ██║ ██║╚██╔╝██║██║ ██║██║╚██╗██║██║ ██║ ██║ ██║██╔══██╗ //
3758// ██║██║ ██║ ██║ ╚═╝ ██║╚██████╔╝██║ ╚████║██║ ██║ ╚██████╔╝██║ ██║ //
3759// ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ //
3760// //
3761//==================================================================================================================//
3762// IIT MONITOR SECTION //
3763//==================================================================================================================//
3764
3766// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3767// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3768// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3770
3773//--------------------------------------
3774// IIT Monitor Parameters
3775//--------------------------------------
3804#define IIT_MONITOR_LIST(X) \
3805 X(THERMAL_WINDING_TIME_CONSTANT_1, 224, ) \
3806 X(IIT_LIMIT_1, 225, ) \
3807 X(IIT_SUM_1, 226, ) \
3808 X(THERMAL_WINDING_TIME_CONSTANT_2, 227, ) \
3809 X(IIT_LIMIT_2, 228, ) \
3810 X(IIT_SUM_2, 229, ) \
3811 X(RESET_IIT_SUMS, 230, ) \
3812 X(ACTUAL_TOTAL_MOTOR_CURRENT, 231, )
3813
3814enum class IitMonitor : uint16_t {
3815 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3816 IIT_MONITOR_LIST(X)
3817 #undef X
3818};
3819
3820inline const char* to_string(IitMonitor e) {
3821 switch(e) {
3822 #define X(NAME, VALUE, DOC) case IitMonitor::NAME: return #NAME;
3823 IIT_MONITOR_LIST(X)
3824 #undef X
3825 default: return "UNKNOWN";
3826 }
3827}
3829
3831// //
3832// ████████╗███████╗███╗ ███╗██████╗ ███████╗██████╗ █████╗ ████████╗██╗ ██╗██████╗ ███████╗ //
3833// ╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██║ ██║██╔══██╗██╔════╝ //
3834// ██║ █████╗ ██╔████╔██║██████╔╝█████╗ ██████╔╝███████║ ██║ ██║ ██║██████╔╝█████╗ //
3835// ██║ ██╔══╝ ██║╚██╔╝██║██╔═══╝ ██╔══╝ ██╔══██╗██╔══██║ ██║ ██║ ██║██╔══██╗██╔══╝ //
3836// ██║ ███████╗██║ ╚═╝ ██║██║ ███████╗██║ ██║██║ ██║ ██║ ╚██████╔╝██║ ██║███████╗ //
3837// ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ //
3838// //
3839// ██████╗ ██████╗ ██████╗ ████████╗███████╗ ██████╗████████╗██╗ ██████╗ ███╗ ██╗███████╗ //
3840// ██╔══██╗██╔══██╗██╔═══██╗╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝██║██╔═══██╗████╗ ██║██╔════╝ //
3841// ██████╔╝██████╔╝██║ ██║ ██║ █████╗ ██║ ██║ ██║██║ ██║██╔██╗ ██║███████╗ //
3842// ██╔═══╝ ██╔══██╗██║ ██║ ██║ ██╔══╝ ██║ ██║ ██║██║ ██║██║╚██╗██║╚════██║ //
3843// ██║ ██║ ██║╚██████╔╝ ██║ ███████╗╚██████╗ ██║ ██║╚██████╔╝██║ ╚████║███████║ //
3844// ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ //
3845// //
3846//==================================================================================================================//
3847// TEMPERATURE PROTECTIONS SECTION //
3848//==================================================================================================================//
3851// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3852// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3853// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3855
3858//--------------------------------------
3859// Temperature Protection Parameters
3860//--------------------------------------
3881#define TEMPERATURE_PROTECTION_LIST(X) \
3882 X(EXTERNAL_TEMPERATURE, 293, ) \
3883 X(EXTERNAL_TEMPERATURE_SHUTDOWN_THRESHOLD, 294, ) \
3884 X(EXTERNAL_TEMPERATURE_WARNING_THRESHOLD, 295, ) \
3885 X(CHIP_TEMPERATURE, 296, ) \
3886 X(CHIP_TEMPERATURE_SHUTDOWN_THRESHOLD, 297, ) \
3887 X(CHIP_TEMPERATURE_WARNING_THRESHOLD, 298, )
3888
3889enum class TemperatureProtection : uint16_t {
3890 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3891 TEMPERATURE_PROTECTION_LIST(X)
3892 #undef X
3893};
3894
3895inline const char* to_string(TemperatureProtection e) {
3896 switch(e) {
3897 #define X(NAME, VALUE, DOC) case TemperatureProtection::NAME: return #NAME;
3898 TEMPERATURE_PROTECTION_LIST(X)
3899 #undef X
3900 default: return "UNKNOWN";
3901 }
3902}
3904
3906// //
3907// ██╗ ██╗███████╗ █████╗ ██████╗ ████████╗██████╗ ███████╗ █████╗ ████████╗ //
3908// ██║ ██║██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██╔══██╗██╔════╝██╔══██╗╚══██╔══╝ //
3909// ███████║█████╗ ███████║██████╔╝ ██║ ██████╔╝█████╗ ███████║ ██║ //
3910// ██╔══██║██╔══╝ ██╔══██║██╔══██╗ ██║ ██╔══██╗██╔══╝ ██╔══██║ ██║ //
3911// ██║ ██║███████╗██║ ██║██║ ██║ ██║ ██████╔╝███████╗██║ ██║ ██║ //
3912// ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ //
3913// //
3914// ███╗ ███╗ ██████╗ ███╗ ██╗██╗████████╗ ██████╗ ██████╗ ██╗███╗ ██╗ ██████╗ //
3915// ████╗ ████║██╔═══██╗████╗ ██║██║╚══██╔══╝██╔═══██╗██╔══██╗██║████╗ ██║██╔════╝ //
3916// ██╔████╔██║██║ ██║██╔██╗ ██║██║ ██║ ██║ ██║██████╔╝██║██╔██╗ ██║██║ ███╗ //
3917// ██║╚██╔╝██║██║ ██║██║╚██╗██║██║ ██║ ██║ ██║██╔══██╗██║██║╚██╗██║██║ ██║ //
3918// ██║ ╚═╝ ██║╚██████╔╝██║ ╚████║██║ ██║ ╚██████╔╝██║ ██║██║██║ ╚████║╚██████╔╝ //
3919// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
3920// //
3921//==================================================================================================================//
3922// HEARTBEAT MONITORING SECTION //
3923//==================================================================================================================//
3925
3927// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3928// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3929// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3931
3934//--------------------------------------
3935// Heartbeat Monitoring Parameters
3936//--------------------------------------
3950#define HEARTBEAT_MONITORING_LIST(X) \
3951 X(HEARTBEAT_MONITORING_CONFIG, 3, ) \
3952 X(HEARTBEAT_MONITORING_TIMEOUT, 4, )
3953
3954enum class HeartbeatMonitoring : uint16_t {
3955 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3956 HEARTBEAT_MONITORING_LIST(X)
3957 #undef X
3958};
3959
3960inline const char* to_string(HeartbeatMonitoring e) {
3961 switch(e) {
3962 #define X(NAME, VALUE, DOC) case HeartbeatMonitoring::NAME: return #NAME;
3963 HEARTBEAT_MONITORING_LIST(X)
3964 #undef X
3965 default: return "UNKNOWN";
3966 }
3967}
3969
3971// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3972// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3973// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3975
3978//--------------------------------------
3979// Heartbeat Monitoring Config
3980//--------------------------------------
3992#define HEARTBEAT_MONITORING_CONFIG_LIST(X) \
3993 X(DISABLED, 0, ) \
3994 X(TMCL_UART_INTERFACE, 1, ) \
3995 X(SPI_INTERFACE, 2, ) \
3996 X(TMCL_UART_AND_SPI_INTERFACE, 3, )
3997
3998enum class HeartbeatMonitoringConfig : uint8_t {
3999 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4000 HEARTBEAT_MONITORING_CONFIG_LIST(X)
4001 #undef X
4002};
4003
4004inline const char* to_string(HeartbeatMonitoringConfig e) {
4005 switch(e) {
4006 #define X(NAME, VALUE, DOC) case HeartbeatMonitoringConfig::NAME: return #NAME;
4007 HEARTBEAT_MONITORING_CONFIG_LIST(X)
4008 #undef X
4009 default: return "UNKNOWN";
4010 }
4011}
4012#undef HEARTBEAT_MONITORING_CONFIG_LIST
4014
4015
4017// //
4018// ██████╗ ██████╗ █████╗ ██╗ ██╗███████╗ ██████╗██╗ ██╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗ //
4019// ██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝██╔════╝ ██╔════╝██║ ██║██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗ //
4020// ██████╔╝██████╔╝███████║█████╔╝ █████╗ ██║ ███████║██║ ██║██████╔╝██████╔╝█████╗ ██████╔╝ //
4021// ██╔══██╗██╔══██╗██╔══██║██╔═██╗ ██╔══╝ ██║ ██╔══██║██║ ██║██╔═══╝ ██╔═══╝ ██╔══╝ ██╔══██╗ //
4022// ██████╔╝██║ ██║██║ ██║██║ ██╗███████╗ ╚██████╗██║ ██║╚██████╔╝██║ ██║ ███████╗██║ ██║ //
4023// ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ //
4024// //
4025//==================================================================================================================//
4026// BRAKE CHOPPER SECTION //
4027//==================================================================================================================//
4029
4031// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4032// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4033// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4035
4038//--------------------------------------
4039// Brake Chopper Parameters
4040//--------------------------------------
4056#define BRAKE_CHOPPER_LIST(X) \
4057 X(BRAKE_CHOPPER_ENABLE, 212, ) \
4058 X(BRAKE_CHOPPER_VOLTAGE_LIMIT, 213, ) \
4059 X(BRAKE_CHOPPER_HYSTERESIS, 214, )
4060
4061enum class BrakeChopper : uint16_t {
4062 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4063 BRAKE_CHOPPER_LIST(X)
4064 #undef X
4065};
4066
4067inline const char* to_string(BrakeChopper e) {
4068 switch(e) {
4069 #define X(NAME, VALUE, DOC) case BrakeChopper::NAME: return #NAME;
4070 BRAKE_CHOPPER_LIST(X)
4071 #undef X
4072 default: return "UNKNOWN";
4073 }
4074}
4076
4078// //
4079// ███╗ ███╗███████╗ ██████╗██╗ ██╗ █████╗ ███╗ ██╗██╗ ██████╗ █████╗ ██╗ //
4080// ████╗ ████║██╔════╝██╔════╝██║ ██║██╔══██╗████╗ ██║██║██╔════╝██╔══██╗██║ //
4081// ██╔████╔██║█████╗ ██║ ███████║███████║██╔██╗ ██║██║██║ ███████║██║ //
4082// ██║╚██╔╝██║██╔══╝ ██║ ██╔══██║██╔══██║██║╚██╗██║██║██║ ██╔══██║██║ //
4083// ██║ ╚═╝ ██║███████╗╚██████╗██║ ██║██║ ██║██║ ╚████║██║╚██████╗██║ ██║███████╗ //
4084// ╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═════╝╚═╝ ╚═╝╚══════╝ //
4085// //
4086// ██████╗ ██████╗ █████╗ ██╗ ██╗███████╗ //
4087// ██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝██╔════╝ //
4088// ██████╔╝██████╔╝███████║█████╔╝ █████╗ //
4089// ██╔══██╗██╔══██╗██╔══██║██╔═██╗ ██╔══╝ //
4090// ██████╔╝██║ ██║██║ ██║██║ ██╗███████╗ //
4091// ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
4092// //
4093//==================================================================================================================//
4094// MECHANICAL BRAKE SECTION //
4095//==================================================================================================================//
4097
4099// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4100// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4101// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4103
4106//--------------------------------------
4107// Mechanical Brake Parameters
4108//--------------------------------------
4127#define MECHANICAL_BRAKE_LIST(X) \
4128 X(RELEASE_BRAKE, 216, ) \
4129 X(BRAKE_RELEASING_DUTY_CYCLE, 217, ) \
4130 X(BRAKE_HOLDING_DUTY_CYCLE, 218, ) \
4131 X(BRAKE_RELEASING_DURATION, 219, ) \
4132 X(INVERT_BRAKE_OUTPUT, 221, )
4133
4134enum class MechanicalBrake : uint16_t {
4135 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4136 MECHANICAL_BRAKE_LIST(X)
4137 #undef X
4138};
4139
4140inline const char* to_string(MechanicalBrake e) {
4141 switch(e) {
4142 #define X(NAME, VALUE, DOC) case MechanicalBrake::NAME: return #NAME;
4143 MECHANICAL_BRAKE_LIST(X)
4144 #undef X
4145 default: return "UNKNOWN";
4146 }
4147}
4149
4151// //
4152// █████╗ ██╗ ██╗████████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██████╗ //
4153// ██╔══██╗██║ ██║╚══██╔══╝██╔═══██╗████╗ ████║██╔══██╗╚══██╔══╝██║██╔════╝ //
4154// ███████║██║ ██║ ██║ ██║ ██║██╔████╔██║███████║ ██║ ██║██║ //
4155// ██╔══██║██║ ██║ ██║ ██║ ██║██║╚██╔╝██║██╔══██║ ██║ ██║██║ //
4156// ██║ ██║╚██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║╚██████╗ //
4157// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ //
4158// //
4159// ██╗ ██╗ ██████╗ ███╗ ███╗██╗███╗ ██╗ ██████╗ //
4160// ██║ ██║██╔═══██╗████╗ ████║██║████╗ ██║██╔════╝ //
4161// ███████║██║ ██║██╔████╔██║██║██╔██╗ ██║██║ ███╗ //
4162// ██╔══██║██║ ██║██║╚██╔╝██║██║██║╚██╗██║██║ ██║ //
4163// ██║ ██║╚██████╔╝██║ ╚═╝ ██║██║██║ ╚████║╚██████╔╝ //
4164// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
4165// //
4166//==================================================================================================================//
4167// AUTOMATIC HOMING SECTION //
4168//==================================================================================================================//
4170
4172// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4173// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4174// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4176
4179//--------------------------------------
4180// Reference Search (Automatic Homing) Parameters
4181//--------------------------------------
4199#define REFERENCE_SEARCH_LIST(X) \
4200 X(REFERENCE_SWITCH_SEARCH_MODE, 165, ) \
4201 X(REFERENCE_SWITCH_SEARCH_SPEED, 166, ) \
4202 X(REFERENCE_SWITCH_SPEED, 167, ) \
4203 X(RIGHT_LIMIT_SWITCH_POSITION, 168, ) \
4204 X(HOME_SWITCH_POSITION, 169, ) \
4205 X(LAST_REFERENCE_POSITION, 170, )
4206
4207enum class ReferenceSearch : uint16_t {
4208 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4209 REFERENCE_SEARCH_LIST(X)
4210 #undef X
4211};
4212
4213inline const char* to_string(ReferenceSearch e) {
4214 switch(e) {
4215 #define X(NAME, VALUE, DOC) case ReferenceSearch::NAME: return #NAME;
4216 REFERENCE_SEARCH_LIST(X)
4217 #undef X
4218 default: return "UNKNOWN";
4219 }
4220}
4222
4224// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4225// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4226// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4228
4231//--------------------------------------
4232// Reference Search Modes
4233//--------------------------------------
4249#define REFERENCE_SEARCH_MODE_LIST(X) \
4250 X(LEFT_SWITCH, 1, ) \
4251 X(RIGHT_SWITCH_LEFT_SWITCH, 2, ) \
4252 X(RIGHT_SWITCH_LEFT_SWITCH_BOTH_SIDES, 3, ) \
4253 X(LEFT_SWITCH_BOTH_SIDES, 4, ) \
4254 X(HOME_SWITCH_NEG_DIR_LEFT_END_SWITCH, 5, ) \
4255 X(HOME_SWITCH_POS_DIR_RIGHT_END_SWITCH, 6, ) \
4256 X(HOME_SWITCH_NEG_DIR_IGNORE_END_SWITCH, 7, ) \
4257 X(HOME_SWITCH_POS_DIR_IGNORE_END_SWITCH, 8, )
4258
4259enum class ReferenceSwitchSearchMode : uint8_t {
4260 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4261 REFERENCE_SEARCH_MODE_LIST(X)
4262 #undef X
4263};
4264
4265inline const char* to_string(ReferenceSwitchSearchMode e) {
4266 switch(e) {
4267 #define X(NAME, VALUE, DOC) case ReferenceSwitchSearchMode::NAME: return #NAME;
4268 REFERENCE_SEARCH_MODE_LIST(X)
4269 #undef X
4270 default: return "UNKNOWN";
4271 }
4272}
4273#undef REFERENCE_SEARCH_MODE_LIST
4275
4278//--------------------------------------
4279// Reference Search TMCL Command Types
4280//--------------------------------------
4291#define REFERENCE_SEARCH_COMMAND_LIST(X) \
4292 X(START, 0, ) \
4293 X(STOP, 1, ) \
4294 X(STATUS, 2, )
4295
4296enum class ReferenceSearchCommand : uint8_t {
4297 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4298 REFERENCE_SEARCH_COMMAND_LIST(X)
4299 #undef X
4300};
4301
4302inline const char* to_string(ReferenceSearchCommand e) {
4303 switch(e) {
4304 #define X(NAME, VALUE, DOC) case ReferenceSearchCommand::NAME: return #NAME;
4305 REFERENCE_SEARCH_COMMAND_LIST(X)
4306 #undef X
4307 default: return "UNKNOWN";
4308 }
4309}
4310#undef REFERENCE_SEARCH_COMMAND_LIST
4312
4315//--------------------------------------
4316// Reference Search Status Codes
4317//--------------------------------------
4341#define REFERENCE_SEARCH_STATUS_LIST(X) \
4342 X(IDLE, 0, ) \
4343 X(START_REFERENCE_DRIVE, 1, ) \
4344 X(START_DRIVE_TO_RIGHT_LIMIT_FAST, 2, ) \
4345 X(WAIT_UNTIL_RIGHT_SWITCH_REACHED, 3, ) \
4346 X(START_DRIVE_TO_LEFT_LIMIT_FAST, 4, ) \
4347 X(WAIT_UNTIL_LEFT_SWITCH_REACHED, 5, ) \
4348 X(DRIVE_OUT_OF_LEFT_SWITCH_SLOWLY, 6, ) \
4349 X(WAIT_UNTIL_LEFT_SWITCH_EXITED_DRIVE_IN_AGAIN, 7, ) \
4350 X(WAIT_UNTIL_LEFT_SWITCH_REACHED_AGAIN_DRIVE_TO_POSITION, 8, ) \
4351 X(WAIT_UNTIL_POSITION_REACHED_SET_ZERO, 9, ) \
4352 X(WAIT_UNTIL_SWITCH_PUSHED_AGAIN, 10, ) \
4353 X(WAIT_UNTIL_OTHER_SIDE_SWITCH_REACHED, 11, ) \
4354 X(RESERVED, 12, ) \
4355 X(WAIT_UNTIL_CENTER_SWITCH_REACHED, 13, ) \
4356 X(REFERENCE_DRIVE_FINISHED_RESTORE_SETTINGS, 14, ) \
4357 X(STOP_REFERENCE_DRIVE, 15, )
4358
4359enum class ReferenceSearchStatus : uint8_t {
4360 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4361 REFERENCE_SEARCH_STATUS_LIST(X)
4362 #undef X
4363};
4364
4365inline const char* to_string(ReferenceSearchStatus e) {
4366 switch(e) {
4367 #define X(NAME, VALUE, DOC) case ReferenceSearchStatus::NAME: return #NAME;
4368 REFERENCE_SEARCH_STATUS_LIST(X)
4369 #undef X
4370 default: return "UNKNOWN";
4371 }
4372}
4373#undef REFERENCE_SEARCH_STATUS_LIST
4375
4377// //
4378// ███████╗████████╗███████╗██████╗ ██╗██████╗ ██╗██████╗ //
4379// ██╔════╝╚══██╔══╝██╔════╝██╔══██╗ ██╔╝██╔══██╗██║██╔══██╗ //
4380// ███████╗ ██║ █████╗ ██████╔╝ ██╔╝ ██║ ██║██║██████╔╝ //
4381// ╚════██║ ██║ ██╔══╝ ██╔═══╝ ██╔╝ ██║ ██║██║██╔══██╗ //
4382// ███████║ ██║ ███████╗██║ ██╔╝ ██████╔╝██║██║ ██║ //
4383// ╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝╚═╝ ╚═╝ //
4384// //
4385//==================================================================================================================//
4386// STEP/DIR SECTION //
4387//==================================================================================================================//
4389
4391// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4392// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4393// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4397//--------------------------------------
4398// Step/Dir Interface Parameters
4399//--------------------------------------
4416#define STEP_DIR_LIST(X) \
4417 /* VELOCITY_FEEDFORWARD_ENABLE defined in VELOCITY_CONTROL_LIST */ \
4418 X(STEP_DIR_STEP_DIVIDER_SHIFT, 205, ) \
4419 X(STEP_DIR_ENABLE, 206, ) \
4420 X(STEP_DIR_EXTRAPOLATION_ENABLE, 207, ) \
4421 X(STEP_DIR_STEP_SIGNAL_TIMEOUT_LIMIT, 208, ) \
4422 X(STEP_DIR_MAXIMUM_EXTRAPOLATION_VELOCITY, 209, )
4423
4424enum class StepDir : uint16_t {
4425 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4426 STEP_DIR_LIST(X)
4427 #undef X
4428};
4429
4430inline const char* to_string(StepDir e) {
4431 switch(e) {
4432 #define X(NAME, VALUE, DOC) case StepDir::NAME: return #NAME;
4433 STEP_DIR_LIST(X)
4434 #undef X
4435 default: return "UNKNOWN";
4436 }
4437}
4439
4441// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4442// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4443// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4445
4448//--------------------------------------
4449// Step/Dir Microstep Divider Shift
4450//--------------------------------------
4470#define STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X) \
4471 X(STEP_MODE_FULL, 0, ) \
4472 X(STEP_MODE_HALF, 1, ) \
4473 X(STEP_MODE_QUARTER, 2, ) \
4474 X(STEP_MODE_1_8TH, 3, ) \
4475 X(STEP_MODE_1_16TH, 4, ) \
4476 X(STEP_MODE_1_32ND, 5, ) \
4477 X(STEP_MODE_1_64TH, 6, ) \
4478 X(STEP_MODE_1_128TH, 7, ) \
4479 X(STEP_MODE_1_256TH, 8, ) \
4480 X(STEP_MODE_1_512TH, 9, ) \
4481 X(STEP_MODE_1_1024TH, 10, )
4482
4483enum class StepDirStepDividerShift : uint8_t {
4484 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4485 STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X)
4486 #undef X
4487};
4488
4489inline const char* to_string(StepDirStepDividerShift e) {
4490 switch(e) {
4491 #define X(NAME, VALUE, DOC) case StepDirStepDividerShift::NAME: return #NAME;
4492 STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X)
4493 #undef X
4494 default: return "UNKNOWN";
4495 }
4496}
4497#undef STEP_DIR_STEP_DIVIDER_SHIFT_LIST
4499
4501// //
4502// ██╗ ██╗██╗██████╗ ███████╗██████╗ ███╗ ██╗ █████╗ ████████╗██╗ ██████╗ ███╗ ██╗ //
4503// ██║ ██║██║██╔══██╗██╔════╝██╔══██╗████╗ ██║██╔══██╗╚══██╔══╝██║██╔═══██╗████╗ ██║ //
4504// ███████║██║██████╔╝█████╗ ██████╔╝██╔██╗ ██║███████║ ██║ ██║██║ ██║██╔██╗ ██║ //
4505// ██╔══██║██║██╔══██╗██╔══╝ ██╔══██╗██║╚██╗██║██╔══██║ ██║ ██║██║ ██║██║╚██╗██║ //
4506// ██║ ██║██║██████╔╝███████╗██║ ██║██║ ╚████║██║ ██║ ██║ ██║╚██████╔╝██║ ╚████║ //
4507// ╚═╝ ╚═╝╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ //
4508// //
4509// █████╗ ███╗ ██╗██████╗ ██╗ ██╗ █████╗ ██╗ ██╗███████╗██╗ ██╗██████╗ //
4510// ██╔══██╗████╗ ██║██╔══██╗ ██║ ██║██╔══██╗██║ ██╔╝██╔════╝██║ ██║██╔══██╗ //
4511// ███████║██╔██╗ ██║██║ ██║ ██║ █╗ ██║███████║█████╔╝ █████╗ ██║ ██║██████╔╝ //
4512// ██╔══██║██║╚██╗██║██║ ██║ ██║███╗██║██╔══██║██╔═██╗ ██╔══╝ ██║ ██║██╔═══╝ //
4513// ██║ ██║██║ ╚████║██████╔╝ ╚███╔███╔╝██║ ██║██║ ██╗███████╗╚██████╔╝██║ //
4514// ╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ╚══╝╚══╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ //
4515// //
4516//==================================================================================================================//
4517// HIBERNATION AND WAKEUP SECTION //
4518//==================================================================================================================//
4520
4522// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4523// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4524// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4526
4529//--------------------------------------
4530// Hibernation and Wakeup Parameters
4531//--------------------------------------
4546#define HIBERNATION_WAKEUP_LIST(X) \
4547 X(WAKE_PIN_CONTROL_ENABLE, 10, ) \
4548 X(GO_TO_TIMEOUT_POWER_DOWN_STATE, 11, )
4549
4550enum class HibernationWakeup : uint16_t {
4551 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4552 HIBERNATION_WAKEUP_LIST(X)
4553 #undef X
4554};
4555
4556inline const char* to_string(HibernationWakeup e) {
4557 switch(e) {
4558 #define X(NAME, VALUE, DOC) case HibernationWakeup::NAME: return #NAME;
4559 HIBERNATION_WAKEUP_LIST(X)
4560 #undef X
4561 default: return "UNKNOWN";
4562 }
4563}
4564
4566// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4567// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4568// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4570
4573//--------------------------------------
4574// Power Down Timeout
4575//--------------------------------------
4591#define POWER_DOWN_TIMEOUT_LIST(X) \
4592 X(T_250_MILLISEC, 0, ) \
4593 X(T_500_MILLISEC, 1, ) \
4594 X(T_1_SEC, 2, ) \
4595 X(T_2_SEC, 3, ) \
4596 X(T_4_SEC, 4, ) \
4597 X(T_8_SEC, 5, ) \
4598 X(T_16_SEC, 6, ) \
4599 X(T_32_SEC, 7, )
4600
4601enum class PowerDownTimeout : uint8_t {
4602 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4603 POWER_DOWN_TIMEOUT_LIST(X)
4604 #undef X
4605};
4606
4607inline const char* to_string(PowerDownTimeout e) {
4608 switch(e) {
4609 #define X(NAME, VALUE, DOC) case PowerDownTimeout::NAME: return #NAME;
4610 POWER_DOWN_TIMEOUT_LIST(X)
4611 #undef X
4612 default: return "UNKNOWN";
4613 }
4614}
4615#undef POWER_DOWN_TIMEOUT_LIST
4616
4618// //
4619// ██╗███╗ ██╗████████╗███████╗██████╗ ███╗ ██╗ █████╗ ██╗ //
4620// ██║████╗ ██║╚══██╔══╝██╔════╝██╔══██╗████╗ ██║██╔══██╗██║ //
4621// ██║██╔██╗ ██║ ██║ █████╗ ██████╔╝██╔██╗ ██║███████║██║ //
4622// ██║██║╚██╗██║ ██║ ██╔══╝ ██╔══██╗██║╚██╗██║██╔══██║██║ //
4623// ██║██║ ╚████║ ██║ ███████╗██║ ██║██║ ╚████║██║ ██║███████╗ //
4624// ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝ //
4625// //
4626// ███╗ ███╗███████╗ █████╗ ███████╗██╗ ██╗██████╗ ███████╗███╗ ███╗███████╗███╗ ██╗████████╗███████╗ //
4627// ████╗ ████║██╔════╝██╔══██╗██╔════╝██║ ██║██╔══██╗██╔════╝████╗ ████║██╔════╝████╗ ██║╚══██╔══╝██╔════╝ //
4628// ██╔████╔██║█████╗ ███████║███████╗██║ ██║██████╔╝█████╗ ██╔████╔██║█████╗ ██╔██╗ ██║ ██║ ███████╗ //
4629// ██║╚██╔╝██║██╔══╝ ██╔══██║╚════██║██║ ██║██╔══██╗██╔══╝ ██║╚██╔╝██║██╔══╝ ██║╚██╗██║ ██║ ╚════██║ //
4630// ██║ ╚═╝ ██║███████╗██║ ██║███████║╚██████╔╝██║ ██║███████╗██║ ╚═╝ ██║███████╗██║ ╚████║ ██║ ███████║ //
4631// ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ //
4632// //
4633//==================================================================================================================//
4634// INTERNAL MEASUREMENTS SECTION //
4635//==================================================================================================================//
4637
4639// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4640// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4641// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4643
4649
4658#define SYSTEM_STATUS_SUPPLY_LIST(X) \
4659 X(SUPPLY_VOLTAGE, 290, ) \
4660 X(SUPPLY_OVERVOLTAGE_WARNING_THRESHOLD, 291, ) \
4661 X(SUPPLY_UNDERVOLTAGE_WARNING_THRESHOLD, 292, )
4662
4663enum class SystemStatusSupply : uint16_t {
4664 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4665 SYSTEM_STATUS_SUPPLY_LIST(X)
4666 #undef X
4667};
4668
4669inline const char* to_string(SystemStatusSupply e) {
4670 switch(e) {
4671 #define X(NAME, VALUE, DOC) case SystemStatusSupply::NAME: return #NAME;
4672 SYSTEM_STATUS_SUPPLY_LIST(X)
4673 #undef X
4674 default: return "UNKNOWN";
4675 }
4676}
4678
4680// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4681// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4682// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4684
4690
4710#define INTERNAL_MEASUREMENT_LIST(X) \
4711 X(MCC_INPUTS_RAW, 304, ) \
4712 X(FOC_VOLTAGE_UX, 305, ) \
4713 X(FOC_VOLTAGE_WY, 306, ) \
4714 X(FOC_VOLTAGE_V, 307, ) \
4715 /* FIELDWEAKENING_I and FIELDWEAKENING_VOLTAGE_THRESHOLD defined in TORQUE_FLUX_CONTROL_LIST */ \
4716 X(FOC_CURRENT_UX, 311, ) \
4717 X(FOC_CURRENT_V, 312, ) \
4718 X(FOC_CURRENT_WY, 313, ) \
4719 X(FOC_VOLTAGE_UQ, 314, ) \
4720 X(FOC_CURRENT_IQ, 315, )
4721
4722enum class InternalMeasurement : uint16_t {
4723 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4724 INTERNAL_MEASUREMENT_LIST(X)
4725 #undef X
4726};
4727
4728inline const char* to_string(InternalMeasurement e) {
4729 switch(e) {
4730 #define X(NAME, VALUE, DOC) case InternalMeasurement::NAME: return #NAME;
4731 INTERNAL_MEASUREMENT_LIST(X)
4732 #undef X
4733 default: return "UNKNOWN";
4734 }
4735}
4737
4739// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4740// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4741// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4743
4749
4764#define COMBINED_DIAGNOSTIC_VALUES_LIST(X) \
4765 X(TORQUE_FLUX_COMBINED_TARGET_VALUES, 330, ) \
4766 X(TORQUE_FLUX_COMBINED_ACTUAL_VALUES, 331, ) \
4767 X(VOLTAGE_D_Q_COMBINED_ACTUAL_VALUES, 332, ) \
4768 X(INTEGRATED_ACTUAL_TORQUE_VALUE, 333, ) \
4769 X(INTEGRATED_ACTUAL_VELOCITY_VALUE, 334, )
4770
4771enum class CombinedDiagnosticValues : uint16_t {
4772 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4773 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
4774 #undef X
4775};
4776
4777inline const char* to_string(CombinedDiagnosticValues e) {
4778 switch(e) {
4779 #define X(NAME, VALUE, DOC) case CombinedDiagnosticValues::NAME: return #NAME;
4780 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
4781 #undef X
4782 default: return "UNKNOWN";
4783 }
4784}
4786
4788// //
4789// ███████╗██████╗ ██████╗ ██████╗ ██████╗ ███████╗ ███████╗██╗ █████╗ ██████╗ ███████╗ //
4790// ██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗██╔════╝ ██╔════╝██║ ██╔══██╗██╔════╝ ██╔════╝ //
4791// █████╗ ██████╔╝██████╔╝██║ ██║██████╔╝███████╗ █████╗ █████╗ ██║ ███████║██║ ███╗███████╗ //
4792// ██╔══╝ ██╔══██╗██╔══██╗██║ ██║██╔══██╗╚════██║ ╚════╝ ██╔══╝ ██║ ██╔══██║██║ ██║╚════██║ //
4793// ███████╗██║ ██║██║ ██║╚██████╔╝██║ ██║███████║ ██║ ███████╗██║ ██║╚██████╔╝███████║ //
4794// ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚══════╝ //
4795// //
4796//==================================================================================================================//
4797// ERRORS & FLAGS SECTION //
4798//==================================================================================================================//
4800
4802// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4803// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4804// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4806
4809//--------------------------------------
4810// Temperature and Error Flags Parameters
4811//--------------------------------------
4828#define ERRORS_AND_FLAGS_LIST(X) \
4829 X(GENERAL_STATUS_FLAGS, 289, ) \
4830 /* Temperature parameters defined in TEMPERATURE_PROTECTION_LIST */ \
4831 X(GENERAL_ERROR_FLAGS, 299, ) \
4832 X(GDRV_ERROR_FLAGS, 300, ) \
4833 X(ADC_STATUS_FLAGS, 301, )
4834
4835enum class ErrorsAndFlags : uint16_t {
4836 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4837 ERRORS_AND_FLAGS_LIST(X)
4838 #undef X
4839};
4840
4841inline const char* to_string(ErrorsAndFlags e) {
4842 switch(e) {
4843 #define X(NAME, VALUE, DOC) case ErrorsAndFlags::NAME: return #NAME;
4844 ERRORS_AND_FLAGS_LIST(X)
4845 #undef X
4846 default: return "UNKNOWN";
4847 }
4848}
4850
4852// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4853// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4854// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4856
4857#define FLAG(bit) (1u << (bit))
4861//--------------------------------------
4862// General Status Flags
4863//--------------------------------------
4907#define GENERAL_STATUS_FLAGS_LIST(X) \
4908 X(REGULATION_STOPPED, FLAG(0), ) \
4909 X(REGULATION_TORQUE, FLAG(1), ) \
4910 X(REGULATION_VELOCITY, FLAG(2), ) \
4911 X(REGULATION_POSITION, FLAG(3), ) \
4912 X(CONFIG_STORED, FLAG(4), ) \
4913 X(CONFIG_LOADED, FLAG(5), ) \
4914 X(CONFIG_READ_ONLY, FLAG(6), ) \
4915 X(TMCL_SCRIPT_READ_ONLY, FLAG(7), ) \
4916 X(BRAKE_CHOPPER_ACTIVE, FLAG(8), ) \
4917 X(POSITION_REACHED, FLAG(9), ) \
4918 X(VELOCITY_REACHED, FLAG(10), ) \
4919 X(ADC_OFFSET_CALIBRATED, FLAG(11), ) \
4920 X(RAMPER_LATCHED, FLAG(12), ) \
4921 X(RAMPER_EVENT_STOP_SWITCH, FLAG(13), ) \
4922 X(RAMPER_EVENT_STOP_DEVIATION, FLAG(14), ) \
4923 X(RAMPER_VELOCITY_REACHED, FLAG(15), ) \
4924 X(RAMPER_POSITION_REACHED, FLAG(16), ) \
4925 X(RAMPER_SECOND_MOVE, FLAG(17), ) \
4926 X(IIT_1_ACTIVE, FLAG(18), ) \
4927 X(IIT_2_ACTIVE, FLAG(19), ) \
4928 X(REFSEARCH_FINISHED, FLAG(20), ) \
4929 X(Y2_USED_FOR_BRAKING, FLAG(21), ) \
4930 X(STEPDIR_INPUT_AVAILABLE, FLAG(23), ) \
4931 X(RIGHT_REF_SWITCH_AVAILABLE, FLAG(24), ) \
4932 X(HOME_REF_SWITCH_AVAILABLE, FLAG(25), ) \
4933 X(LEFT_REF_SWITCH_AVAILABLE, FLAG(26), ) \
4934 X(ABN2_FEEDBACK_AVAILABLE, FLAG(27), ) \
4935 X(HALL_FEEDBACK_AVAILABLE, FLAG(28), ) \
4936 X(ABN1_FEEDBACK_AVAILABLE, FLAG(29), ) \
4937 X(SPI_FLASH_AVAILABLE, FLAG(30), ) \
4938 X(I2C_EEPROM_AVAILABLE, FLAG(31), )
4939
4940enum class GeneralStatusFlags : uint32_t {
4941 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4942 GENERAL_STATUS_FLAGS_LIST(X)
4943 #undef X
4944};
4945
4946inline const char* to_string(GeneralStatusFlags e) {
4947 switch(e) {
4948 #define X(NAME, VALUE, DOC) case GeneralStatusFlags::NAME: return #NAME;
4949 GENERAL_STATUS_FLAGS_LIST(X)
4950 #undef X
4951 default: return "UNKNOWN";
4952 }
4953}
4954#undef GENERAL_STATUS_FLAGS_LIST
4956
4959//--------------------------------------
4960// General Error Flags
4961//--------------------------------------
4989#define GENERAL_ERROR_FLAGS_LIST(X) \
4990 X(CONFIG_ERROR, FLAG(0), ) \
4991 X(TMCL_SCRIPT_ERROR, FLAG(1), ) \
4992 X(HOMESWITCH_NOT_FOUND, FLAG(2), ) \
4993 X(HALL_ERROR, FLAG(5), ) \
4994 X(WATCHDOG_EVENT, FLAG(9), ) \
4995 X(EXT_TEMP_EXCEEDED, FLAG(13), ) \
4996 X(CHIP_TEMP_EXCEEDED, FLAG(14), ) \
4997 X(I2T_1_EXCEEDED, FLAG(16), ) \
4998 X(I2T_2_EXCEEDED, FLAG(17), ) \
4999 X(EXT_TEMP_WARNING, FLAG(18), ) \
5000 X(SUPPLY_OVERVOLTAGE_WARNING, FLAG(19), ) \
5001 X(SUPPLY_UNDERVOLTAGE_WARNING, FLAG(20), ) \
5002 X(ADC_IN_OVERVOLTAGE, FLAG(21), ) \
5003 X(FAULT_RETRY_HAPPENED, FLAG(22), ) \
5004 X(FAULT_RETRIES_FAILED, FLAG(23), ) \
5005 X(CHIP_TEMP_WARNING, FLAG(24), ) \
5006 X(HEARTBEAT_STOPPED, FLAG(26), )
5007
5008enum class GeneralErrorFlags : uint32_t {
5009 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5010 GENERAL_ERROR_FLAGS_LIST(X)
5011 #undef X
5012};
5013
5014inline const char* to_string(GeneralErrorFlags e) {
5015 switch(e) {
5016 #define X(NAME, VALUE, DOC) case GeneralErrorFlags::NAME: return #NAME;
5017 GENERAL_ERROR_FLAGS_LIST(X)
5018 #undef X
5019 default: return "UNKNOWN";
5020 }
5021}
5022#undef GENERAL_ERROR_FLAGS_LIST
5024
5027//--------------------------------------
5028// Gate Driver Error Flags
5029//--------------------------------------
5067#define GATE_DRIVER_ERROR_FLAGS_LIST(X) \
5068 X(U_LOW_SIDE_OVERCURRENT, FLAG(0), ) \
5069 X(V_LOW_SIDE_OVERCURRENT, FLAG(1), ) \
5070 X(W_LOW_SIDE_OVERCURRENT, FLAG(2), ) \
5071 X(Y2_LOW_SIDE_OVERCURRENT, FLAG(3), ) \
5072 X(U_LOW_SIDE_DISCHARGE_SHORT, FLAG(4), ) \
5073 X(V_LOW_SIDE_DISCHARGE_SHORT, FLAG(5), ) \
5074 X(W_LOW_SIDE_DISCHARGE_SHORT, FLAG(6), ) \
5075 X(Y2_LOW_SIDE_DISCHARGE_SHORT, FLAG(7), ) \
5076 X(U_LOW_SIDE_CHARGE_SHORT, FLAG(8), ) \
5077 X(V_LOW_SIDE_CHARGE_SHORT, FLAG(9), ) \
5078 X(W_LOW_SIDE_CHARGE_SHORT, FLAG(10), ) \
5079 X(Y2_LOW_SIDE_CHARGE_SHORT, FLAG(11), ) \
5080 X(U_BOOTSTRAP_UNDERVOLTAGE, FLAG(12), ) \
5081 X(V_BOOTSTRAP_UNDERVOLTAGE, FLAG(13), ) \
5082 X(W_BOOTSTRAP_UNDERVOLTAGE, FLAG(14), ) \
5083 X(Y2_BOOTSTRAP_UNDERVOLTAGE, FLAG(15), ) \
5084 X(U_HIGH_SIDE_OVERCURRENT, FLAG(16), ) \
5085 X(V_HIGH_SIDE_OVERCURRENT, FLAG(17), ) \
5086 X(W_HIGH_SIDE_OVERCURRENT, FLAG(18), ) \
5087 X(Y2_HIGH_SIDE_OVERCURRENT, FLAG(19), ) \
5088 X(U_HIGH_SIDE_DISCHARGE_SHORT, FLAG(20), ) \
5089 X(V_HIGH_SIDE_DISCHARGE_SHORT, FLAG(21), ) \
5090 X(W_HIGH_SIDE_DISCHARGE_SHORT, FLAG(22), ) \
5091 X(Y2_HIGH_SIDE_DISCHARGE_SHORT, FLAG(23), ) \
5092 X(U_HIGH_SIDE_CHARGE_SHORT, FLAG(24), ) \
5093 X(V_HIGH_SIDE_CHARGE_SHORT, FLAG(25), ) \
5094 X(W_HIGH_SIDE_CHARGE_SHORT, FLAG(26), ) \
5095 X(Y2_HIGH_SIDE_CHARGE_SHORT, FLAG(27), ) \
5096 X(GDRV_UNDERVOLTAGE, FLAG(29), ) \
5097 X(GDRV_LOW_VOLTAGE, FLAG(30), ) \
5098 X(GDRV_SUPPLY_UNDERVOLTAGE, FLAG(31), )
5099
5100enum class GateDriverErrorFlags : uint32_t {
5101 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5102 GATE_DRIVER_ERROR_FLAGS_LIST(X)
5103 #undef X
5104};
5105
5106inline const char* to_string(GateDriverErrorFlags e) {
5107 switch(e) {
5108 #define X(NAME, VALUE, DOC) case GateDriverErrorFlags::NAME: return #NAME;
5109 GATE_DRIVER_ERROR_FLAGS_LIST(X)
5110 #undef X
5111 default: return "UNKNOWN";
5112 }
5113}
5114#undef GATE_DRIVER_ERROR_FLAGS_LIST
5116
5120// ADC Status Flags
5121//--------------------------------------
5142#define ADC_STATUS_FLAGS_LIST(X) \
5143 X(I0_CLIPPED, 0x00000001, ) \
5144 X(I1_CLIPPED, 0x00000002, ) \
5145 X(I2_CLIPPED, 0x00000004, ) \
5146 X(I3_CLIPPED, 0x00000008, ) \
5147 X(U0_CLIPPED, 0x00000010, ) \
5148 X(U1_CLIPPED, 0x00000020, ) \
5149 X(U2_CLIPPED, 0x00000040, ) \
5150 X(U3_CLIPPED, 0x00000080, ) \
5151 X(AIN0_CLIPPED, 0x00000100, ) \
5152 X(AIN1_CLIPPED, 0x00000200, ) \
5153 X(AIN2_CLIPPED, 0x00000400, ) \
5154 X(AIN3_CLIPPED, 0x00000800, ) \
5155 X(VM_CLIPPED, 0x00001000, ) \
5156 X(TEMP_CLIPPED, 0x00002000, )
5157
5158enum class AdcStatusFlags : uint32_t {
5159 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5160 ADC_STATUS_FLAGS_LIST(X)
5161 #undef X
5162};
5163
5164inline const char* to_string(AdcStatusFlags e) {
5165 switch(e) {
5166 #define X(NAME, VALUE, DOC) case AdcStatusFlags::NAME: return #NAME;
5167 ADC_STATUS_FLAGS_LIST(X)
5168 #undef X
5169 default: return "UNKNOWN";
5170 }
5171}
5172#undef ADC_STATUS_FLAGS_LIST
5174
5176// //
5177// ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
5178// ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
5179// ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
5180// ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
5181// ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
5182// ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
5183// //
5184//==================================================================================================================//
5185// PARAMETERS //
5186//==================================================================================================================//
5188
5189enum class Parameters : uint16_t {
5190 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5191
5192 // Gate driver - parameters and configurations
5193 GATE_DRIVER_LIST(X)
5194
5195 // Gate driver - Overcurrent protection settings
5196 OVERCURRENT_PROTECTION_LIST(X)
5197
5198 // Gate driver - Undervoltage (UVLO) protection settings
5199 UNDERVOLTAGE_PROTECTION_LIST(X)
5200
5201 // Gate driver - Gate-to-source (VGS) short-circuit protection settings
5202 VGS_SHORT_PROTECTION_LIST(X)
5203
5204 // Motor configuration and drive settings
5205 MOTOR_CONFIG_LIST(X)
5206
5207 // ADC configuration for motor current measurement
5208 ADC_CONFIG_LIST(X)
5209
5210 // Feedback sensors (ABN, Hall, SPI encoders)
5211 FEEDBACK_SENSOR_CONFIG_LIST(X)
5212
5213 // Torque & flux control loops
5214 TORQUE_FLUX_CONTROL_LIST(X)
5215
5216 // Velocity control & ramping
5217 VELOCITY_CONTROL_LIST(X)
5218
5219 // Position control & ramping
5220 POSITION_CONTROL_LIST(X)
5221
5222 // Ramper stop conditions & reference switch
5223 RAMPER_STOP_CONFIG_LIST(X)
5224
5225 // Biquad filter parameters
5226 BIQUAD_FILTER_LIST(X)
5227
5228 // Fault-handling / retry behavior
5229 FAULT_HANDLING_LIST(X)
5230
5231 // I²t monitoring
5232 IIT_MONITOR_LIST(X)
5233
5234 // Temperature protection
5235 TEMPERATURE_PROTECTION_LIST(X)
5236
5237 // Heartbeat monitoring
5238 HEARTBEAT_MONITORING_LIST(X)
5239
5240 // Brake chopper settings
5241 BRAKE_CHOPPER_LIST(X)
5242
5243 // Mechanical brake parameters
5244 MECHANICAL_BRAKE_LIST(X)
5245
5246 // Automatic homing / reference search
5247 REFERENCE_SEARCH_LIST(X)
5248
5249 // STEP/DIR interface
5250 STEP_DIR_LIST(X)
5251
5252 // Hibernation & wakeup
5253 HIBERNATION_WAKEUP_LIST(X)
5254
5255 // System status and supply monitoring
5256 SYSTEM_STATUS_SUPPLY_LIST(X)
5257
5258 // Internal measurement parameters
5259 INTERNAL_MEASUREMENT_LIST(X)
5260
5261 // Combined diagnostic values
5262 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
5263
5264 // Error flags and status monitoring
5265 ERRORS_AND_FLAGS_LIST(X)
5266
5267 #undef X
5268};
5269
5270/* ───────────── Clean-up (optional but tidy) ───────────── */
5271// Undefine all parameter-section X-macros to avoid polluting the global namespace.
5272#undef GATE_DRIVER_LIST
5273#undef OVERCURRENT_PROTECTION_LIST
5274#undef UNDERVOLTAGE_PROTECTION_LIST
5275#undef VGS_SHORT_PROTECTION_LIST
5276#undef MOTOR_CONFIG_LIST
5277#undef ADC_CONFIG_LIST
5278#undef FEEDBACK_SENSOR_CONFIG_LIST
5279#undef TORQUE_FLUX_CONTROL_LIST
5280#undef VELOCITY_CONTROL_LIST
5281#undef POSITION_CONTROL_LIST
5282#undef RAMPER_STOP_CONFIG_LIST
5283#undef BIQUAD_FILTER_LIST
5284#undef FAULT_HANDLING_LIST
5285#undef IIT_MONITOR_LIST
5286#undef TEMPERATURE_PROTECTION_LIST
5287#undef HEARTBEAT_MONITORING_LIST
5288#undef BRAKE_CHOPPER_LIST
5289#undef MECHANICAL_BRAKE_LIST
5290#undef REFERENCE_SEARCH_LIST
5291#undef STEP_DIR_LIST
5292#undef HIBERNATION_WAKEUP_LIST
5293#undef SYSTEM_STATUS_SUPPLY_LIST
5294#undef INTERNAL_MEASUREMENT_LIST
5295#undef COMBINED_DIAGNOSTIC_VALUES_LIST
5296#undef ERRORS_AND_FLAGS_LIST
5297
5298// clang-format on
5299} // namespace tmc9660::tmcl
tmc9660::tmcl
Definition tmc9660_param_mode_tmcl.hpp:14
tmc9660::tmcl::IitMonitor
IitMonitor
Definition tmc9660_param_mode_tmcl.hpp:3814
tmc9660::tmcl::UndervoltageEnable
UndervoltageEnable
Definition tmc9660_param_mode_tmcl.hpp:1274
tmc9660::tmcl::ReferenceSwitchEnable
ReferenceSwitchEnable
Definition tmc9660_param_mode_tmcl.hpp:3293
tmc9660::tmcl::CombinedDiagnosticValues
CombinedDiagnosticValues
Definition tmc9660_param_mode_tmcl.hpp:4771
tmc9660::tmcl::AbnInitState
AbnInitState
Definition tmc9660_param_mode_tmcl.hpp:2309
tmc9660::tmcl::ReferenceSearchCommand
ReferenceSearchCommand
Definition tmc9660_param_mode_tmcl.hpp:4296
tmc9660::tmcl::PwmFrequency
PwmFrequency
Definition tmc9660_param_mode_tmcl.hpp:2079
tmc9660::tmcl::WaitCondition
WaitCondition
Definition tmc9660_param_mode_tmcl.hpp:243
tmc9660::tmcl::GateCurrentSource
GateCurrentSource
Definition tmc9660_param_mode_tmcl.hpp:838
tmc9660::tmcl::GateCurrentSink
GateCurrentSink
Definition tmc9660_param_mode_tmcl.hpp:778
tmc9660::tmcl::OvercurrentTiming
OvercurrentTiming
Definition tmc9660_param_mode_tmcl.hpp:1096
tmc9660::tmcl::HeartbeatMonitoring
HeartbeatMonitoring
Definition tmc9660_param_mode_tmcl.hpp:3954
tmc9660::tmcl::RamDebugState
RamDebugState
Definition tmc9660_param_mode_tmcl.hpp:388
tmc9660::tmcl::EventStopSettings
EventStopSettings
Definition tmc9660_param_mode_tmcl.hpp:3466
tmc9660::tmcl::ReferenceSearchStatus
ReferenceSearchStatus
Definition tmc9660_param_mode_tmcl.hpp:4359
tmc9660::tmcl::ReferenceSearch
ReferenceSearch
Definition tmc9660_param_mode_tmcl.hpp:4207
tmc9660::tmcl::SystemStatusSupply
SystemStatusSupply
Definition tmc9660_param_mode_tmcl.hpp:4663
tmc9660::tmcl::AdcMapping
AdcMapping
Definition tmc9660_param_mode_tmcl.hpp:2009
tmc9660::tmcl::OvercurrentThreshold
OvercurrentThreshold
Definition tmc9660_param_mode_tmcl.hpp:1052
tmc9660::tmcl::VgsShortEnable
VgsShortEnable
Definition tmc9660_param_mode_tmcl.hpp:1357
tmc9660::tmcl::BrakeChopper
BrakeChopper
Definition tmc9660_param_mode_tmcl.hpp:4061
tmc9660::tmcl::to_string
const char * to_string(Op op)
Definition tmc9660_param_mode_tmcl.hpp:159
tmc9660::tmcl::FaultHandling
FaultHandling
Definition tmc9660_param_mode_tmcl.hpp:3656
tmc9660::tmcl::PowerDownTimeout
PowerDownTimeout
Definition tmc9660_param_mode_tmcl.hpp:4601
tmc9660::tmcl::CommutationMode
CommutationMode
Definition tmc9660_param_mode_tmcl.hpp:1726
tmc9660::tmcl::StepDirStepDividerShift
StepDirStepDividerShift
Definition tmc9660_param_mode_tmcl.hpp:4483
tmc9660::tmcl::BiquadFilterEnable
BiquadFilterEnable
Definition tmc9660_param_mode_tmcl.hpp:3594
tmc9660::tmcl::VelocityPiNorm
VelocityPiNorm
Definition tmc9660_param_mode_tmcl.hpp:2907
tmc9660::tmcl::MotorDirection
MotorDirection
Definition tmc9660_param_mode_tmcl.hpp:1573
tmc9660::tmcl::PositionControl
PositionControl
Definition tmc9660_param_mode_tmcl.hpp:3070
tmc9660::tmcl::VgsBlankingTime
VgsBlankingTime
Definition tmc9660_param_mode_tmcl.hpp:1393
tmc9660::tmcl::DriveFaultBehaviour
DriveFaultBehaviour
Definition tmc9660_param_mode_tmcl.hpp:3735
tmc9660::tmcl::Direction
Direction
Definition tmc9660_param_mode_tmcl.hpp:2519
tmc9660::tmcl::AdcStatusFlags
AdcStatusFlags
Definition tmc9660_param_mode_tmcl.hpp:5158
tmc9660::tmcl::RamperStopConfig
RamperStopConfig
Definition tmc9660_param_mode_tmcl.hpp:3241
tmc9660::tmcl::BootstrapCurrentLimit
BootstrapCurrentLimit
Definition tmc9660_param_mode_tmcl.hpp:882
tmc9660::tmcl::VdsUsage
VdsUsage
Definition tmc9660_param_mode_tmcl.hpp:1128
tmc9660::tmcl::GdrvRetryBehaviour
GdrvRetryBehaviour
Definition tmc9660_param_mode_tmcl.hpp:3696
tmc9660::tmcl::SpiEncoderTransfer
SpiEncoderTransfer
Definition tmc9660_param_mode_tmcl.hpp:2421
tmc9660::tmcl::GeneralStatusFlags
GeneralStatusFlags
Definition tmc9660_param_mode_tmcl.hpp:4940
tmc9660::tmcl::MechanicalBrake
MechanicalBrake
Definition tmc9660_param_mode_tmcl.hpp:4134
tmc9660::tmcl::CsaFilter
CsaFilter
Definition tmc9660_param_mode_tmcl.hpp:1973
tmc9660::tmcl::PwmSwitchingScheme
PwmSwitchingScheme
Definition tmc9660_param_mode_tmcl.hpp:1607
tmc9660::tmcl::EnableDisable
EnableDisable
Definition tmc9660_param_mode_tmcl.hpp:2487
tmc9660::tmcl::GateDriverErrorFlags
GateDriverErrorFlags
Definition tmc9660_param_mode_tmcl.hpp:5100
tmc9660::tmcl::VelocityControl
VelocityControl
Definition tmc9660_param_mode_tmcl.hpp:2822
tmc9660::tmcl::ReplyCode
ReplyCode
Definition tmc9660_param_mode_tmcl.hpp:291
tmc9660::tmcl::HibernationWakeup
HibernationWakeup
Definition tmc9660_param_mode_tmcl.hpp:4550
tmc9660::tmcl::ErrorsAndFlags
ErrorsAndFlags
Definition tmc9660_param_mode_tmcl.hpp:4835
tmc9660::tmcl::InternalMeasurement
InternalMeasurement
Definition tmc9660_param_mode_tmcl.hpp:4722
tmc9660::tmcl::VelocityMeterMode
VelocityMeterMode
Definition tmc9660_param_mode_tmcl.hpp:2944
tmc9660::tmcl::GeneralErrorFlags
GeneralErrorFlags
Definition tmc9660_param_mode_tmcl.hpp:5008
tmc9660::tmcl::AdcShuntType
AdcShuntType
Definition tmc9660_param_mode_tmcl.hpp:1899
tmc9660::tmcl::GateDriver
GateDriver
Definition tmc9660_param_mode_tmcl.hpp:681
tmc9660::tmcl::CurrentPiNormalization
CurrentPiNormalization
Definition tmc9660_param_mode_tmcl.hpp:2693
tmc9660::tmcl::ReferenceSwitchSearchMode
ReferenceSwitchSearchMode
Definition tmc9660_param_mode_tmcl.hpp:4259
tmc9660::tmcl::RamDebugType
RamDebugType
Definition tmc9660_param_mode_tmcl.hpp:349
tmc9660::tmcl::PwmOutputPolarity
PwmOutputPolarity
Definition tmc9660_param_mode_tmcl.hpp:718
tmc9660::tmcl::UndervoltageProtection
UndervoltageProtection
Definition tmc9660_param_mode_tmcl.hpp:1173
tmc9660::tmcl::TorqueFluxControl
TorqueFluxControl
Definition tmc9660_param_mode_tmcl.hpp:2618
tmc9660::tmcl::PositionPiNorm
PositionPiNorm
Definition tmc9660_param_mode_tmcl.hpp:3155
tmc9660::tmcl::FeedbackSensorConfig
FeedbackSensorConfig
Definition tmc9660_param_mode_tmcl.hpp:2232
tmc9660::tmcl::SpiInitMethod
SpiInitMethod
Definition tmc9660_param_mode_tmcl.hpp:2455
tmc9660::tmcl::AdcInversion
AdcInversion
Definition tmc9660_param_mode_tmcl.hpp:2041
tmc9660::tmcl::Op
Op
Definition tmc9660_param_mode_tmcl.hpp:153
tmc9660::tmcl::Op::X
X(NAME, VALUE, DOC)
tmc9660::tmcl::GlobalParamBank3
GlobalParamBank3
Definition tmc9660_param_mode_tmcl.hpp:538
tmc9660::tmcl::GlobalParamBank0
GlobalParamBank0
Definition tmc9660_param_mode_tmcl.hpp:449
tmc9660::tmcl::TorqueFluxPiSeparation
TorqueFluxPiSeparation
Definition tmc9660_param_mode_tmcl.hpp:2658
tmc9660::tmcl::OvercurrentEnable
OvercurrentEnable
Definition tmc9660_param_mode_tmcl.hpp:992
tmc9660::tmcl::BiquadFilter
BiquadFilter
Definition tmc9660_param_mode_tmcl.hpp:3554
tmc9660::tmcl::MotorConfig
MotorConfig
Definition tmc9660_param_mode_tmcl.hpp:1500
tmc9660::tmcl::CalcOperation
CalcOperation
Definition tmc9660_param_mode_tmcl.hpp:184
tmc9660::tmcl::Parameters
Parameters
Definition tmc9660_param_mode_tmcl.hpp:5189
tmc9660::tmcl::ReferenceSwitchPolaritySwap
ReferenceSwitchPolaritySwap
Definition tmc9660_param_mode_tmcl.hpp:3356
tmc9660::tmcl::CsaGain
CsaGain
Definition tmc9660_param_mode_tmcl.hpp:1937
tmc9660::tmcl::StepDir
StepDir
Definition tmc9660_param_mode_tmcl.hpp:4424
tmc9660::tmcl::VelocitySensorSelection
VelocitySensorSelection
Definition tmc9660_param_mode_tmcl.hpp:2868
tmc9660::tmcl::MotorType
MotorType
Definition tmc9660_param_mode_tmcl.hpp:1541
tmc9660::tmcl::VgsDeglitchTime
VgsDeglitchTime
Definition tmc9660_param_mode_tmcl.hpp:1437
tmc9660::tmcl::VgsShortProtection
VgsShortProtection
Definition tmc9660_param_mode_tmcl.hpp:1320
tmc9660::tmcl::HeartbeatMonitoringConfig
HeartbeatMonitoringConfig
Definition tmc9660_param_mode_tmcl.hpp:3998
tmc9660::tmcl::ReferenceSwitchLatchSettings
ReferenceSwitchLatchSettings
Definition tmc9660_param_mode_tmcl.hpp:3419
tmc9660::tmcl::AbnNChannelFiltering
AbnNChannelFiltering
Definition tmc9660_param_mode_tmcl.hpp:2347
tmc9660::tmcl::HallSectorOffset
HallSectorOffset
Definition tmc9660_param_mode_tmcl.hpp:2387
tmc9660::tmcl::PositionSensorSelection
PositionSensorSelection
Definition tmc9660_param_mode_tmcl.hpp:3116
tmc9660::tmcl::OvercurrentProtection
OvercurrentProtection
Definition tmc9660_param_mode_tmcl.hpp:955
tmc9660::tmcl::UndervoltageLevel
UndervoltageLevel
Definition tmc9660_param_mode_tmcl.hpp:1242
tmc9660::tmcl::TriggerTransition
TriggerTransition
Definition tmc9660_param_mode_tmcl.hpp:581
tmc9660::tmcl::AbnInitMethod
AbnInitMethod
Definition tmc9660_param_mode_tmcl.hpp:2273
tmc9660::tmcl::TemperatureProtection
TemperatureProtection
Definition tmc9660_param_mode_tmcl.hpp:3889
tmc9660::tmcl::AdcConfig
AdcConfig
Definition tmc9660_param_mode_tmcl.hpp:1856
tmc9660::tmcl::GlobalParamBank2
GlobalParamBank2
Definition tmc9660_param_mode_tmcl.hpp:489
tmc9660::tmcl::AccelerationFFShift
AccelerationFFShift
Definition tmc9660_param_mode_tmcl.hpp:2989
tmc9660::tmcl::IdleMotorPwmBehavior
IdleMotorPwmBehavior
Definition tmc9660_param_mode_tmcl.hpp:1761
tmc9660::tmcl::JumpCondition
JumpCondition
Definition tmc9660_param_mode_tmcl.hpp:214
HALL_SECTOR_OFFSET_LIST
#define HALL_SECTOR_OFFSET_LIST(X)
Enumerates Hall sector offsets.
Definition tmc9660_param_mode_tmcl.hpp:2379
GATE_CURRENT_SOURCE_LIST
#define GATE_CURRENT_SOURCE_LIST(X)
Enumerates possible values for UVW_SOURCE_CURRENT and Y2_SOURCE_CURRENT (25–1000mA).
Definition tmc9660_param_mode_tmcl.hpp:820
COMMUTATION_MODE_LIST
#define COMMUTATION_MODE_LIST(X)
Commutation modes define how the motor shaft angle is determined and the system's state.
Definition tmc9660_param_mode_tmcl.hpp:1715
GLOBAL_PARAM_BANK2_LIST
#define GLOBAL_PARAM_BANK2_LIST(X)
User-script variables 0…15. RWE.
Definition tmc9660_param_mode_tmcl.hpp:471
RAMPER_STOP_CONFIG_LIST
#define RAMPER_STOP_CONFIG_LIST(X)
Parameters for configuring ramper stop conditions and reference switch behavior.
Definition tmc9660_param_mode_tmcl.hpp:3232
FAULT_HANDLING_LIST
#define FAULT_HANDLING_LIST(X)
Parameters for configuring system behavior on fault conditions.
Definition tmc9660_param_mode_tmcl.hpp:3651
VGS_DEGLITCH_TIME_LIST
#define VGS_DEGLITCH_TIME_LIST(X)
Enumerates possible deglitch times for VGS short protection.
Definition tmc9660_param_mode_tmcl.hpp:1427
STEP_DIR_STEP_DIVIDER_SHIFT_LIST
#define STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X)
Enumerates micro-step divider shift settings for STEP/DIR interface.
Definition tmc9660_param_mode_tmcl.hpp:4470
ABN_INIT_METHOD_LIST
#define ABN_INIT_METHOD_LIST(X)
Enumerates ABN encoder initialization methods.
Definition tmc9660_param_mode_tmcl.hpp:2267
MOTOR_DIRECTION_LIST
#define MOTOR_DIRECTION_LIST(X)
Enumerates motor rotation directions.
Definition tmc9660_param_mode_tmcl.hpp:1569
INTERNAL_MEASUREMENT_LIST
#define INTERNAL_MEASUREMENT_LIST(X)
Raw diagnostic values and FOC internal measurements.
Definition tmc9660_param_mode_tmcl.hpp:4710
VGS_SHORT_PROTECTION_LIST
#define VGS_SHORT_PROTECTION_LIST(X)
Parameters for configuring gate-to-source (VGS) short circuit protection.
Definition tmc9660_param_mode_tmcl.hpp:1306
REFERENCE_SEARCH_MODE_LIST
#define REFERENCE_SEARCH_MODE_LIST(X)
Enumerates reference search (homing) patterns.
Definition tmc9660_param_mode_tmcl.hpp:4249
TRIGGER_TRANSITION_LIST
#define TRIGGER_TRANSITION_LIST(X)
For all "_TRIGGER_TRANSITION" params: 0=OFF, 1=RISING, 2=FALLING, 3=BOTH.
Definition tmc9660_param_mode_tmcl.hpp:575
SPI_INIT_METHOD_LIST
#define SPI_INIT_METHOD_LIST(X)
Enumerates SPI encoder initialization methods.
Definition tmc9660_param_mode_tmcl.hpp:2450
OVERCURRENT_TIMING_LIST
#define OVERCURRENT_TIMING_LIST(X)
Enumerates possible blanking and deglitch times for overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1086
POSITION_SENSOR_SELECTION_LIST
#define POSITION_SENSOR_SELECTION_LIST(X)
Enumerates feedback sources for position PI regulator.
Definition tmc9660_param_mode_tmcl.hpp:3109
PWM_FREQUENCY_LIST
#define PWM_FREQUENCY_LIST(X)
Enumerates recommended PWM frequencies for different motor types.
Definition tmc9660_param_mode_tmcl.hpp:2072
ABN_N_CHANNEL_FILTERING_LIST
#define ABN_N_CHANNEL_FILTERING_LIST(X)
Enumerates ABN N-channel filtering modes.
Definition tmc9660_param_mode_tmcl.hpp:2340
GDRV_RETRY_BEHAVIOUR_LIST
#define GDRV_RETRY_BEHAVIOUR_LIST(X)
System state after a gate driver fault occurs.
Definition tmc9660_param_mode_tmcl.hpp:3692
IIT_MONITOR_LIST
#define IIT_MONITOR_LIST(X)
Parameters for configuring IIT (I²t) monitoring and protection.
Definition tmc9660_param_mode_tmcl.hpp:3804
GLOBAL_PARAM_BANK0_LIST
#define GLOBAL_PARAM_BANK0_LIST(X)
Non-motion parameters in bank 0: communication, I/O, heartbeat, hibernation, loops,...
Definition tmc9660_param_mode_tmcl.hpp:433
TORQUE_FLUX_PI_SEPARATION_LIST
#define TORQUE_FLUX_PI_SEPARATION_LIST(X)
Selects if torque and flux PI controllers use separate parameters.
Definition tmc9660_param_mode_tmcl.hpp:2654
VELOCITY_PI_NORM_LIST
#define VELOCITY_PI_NORM_LIST(X)
Enumerates normalization formats for velocity PI controller.
Definition tmc9660_param_mode_tmcl.hpp:2901
DRIVE_FAULT_BEHAVIOUR_LIST
#define DRIVE_FAULT_BEHAVIOUR_LIST(X)
System state after all retries fail following a fault.
Definition tmc9660_param_mode_tmcl.hpp:3729
ADC_SHUNT_TYPE_LIST
#define ADC_SHUNT_TYPE_LIST(X)
Enumerates shunt types for ADC measurements.
Definition tmc9660_param_mode_tmcl.hpp:1892
DIRECTION_LIST
#define DIRECTION_LIST(X)
Direction settings used by various encoder parameters.
Definition tmc9660_param_mode_tmcl.hpp:2515
OP_LIST
#define OP_LIST(X)
Operation codes accepted by the TMC9660 Parameter Mode (Table 18).
Definition tmc9660_param_mode_tmcl.hpp:100
POSITION_PI_NORM_LIST
#define POSITION_PI_NORM_LIST(X)
Enumerates normalization formats for position PI controller.
Definition tmc9660_param_mode_tmcl.hpp:3149
GENERAL_STATUS_FLAGS_LIST
#define GENERAL_STATUS_FLAGS_LIST(X)
General status flags indicating system state, events, and hardware availability.
Definition tmc9660_param_mode_tmcl.hpp:4907
SYSTEM_STATUS_SUPPLY_LIST
#define SYSTEM_STATUS_SUPPLY_LIST(X)
Parameters for supply voltage warnings.
Definition tmc9660_param_mode_tmcl.hpp:4658
POWER_DOWN_TIMEOUT_LIST
#define POWER_DOWN_TIMEOUT_LIST(X)
Enumerates timeout durations for power-down state.
Definition tmc9660_param_mode_tmcl.hpp:4591
ERRORS_AND_FLAGS_LIST
#define ERRORS_AND_FLAGS_LIST(X)
Parameters for temperature monitoring and error flags.
Definition tmc9660_param_mode_tmcl.hpp:4828
VELOCITY_SENSOR_SELECTION_LIST
#define VELOCITY_SENSOR_SELECTION_LIST(X)
Enumerates feedback sources for velocity PI regulator.
Definition tmc9660_param_mode_tmcl.hpp:2861
IDLE_MOTOR_PWM_BEHAVIOR_LIST
#define IDLE_MOTOR_PWM_BEHAVIOR_LIST(X)
PWM behavior in commutation mode "System Off" (Parameter ID: 9).
Definition tmc9660_param_mode_tmcl.hpp:1757
COMBINED_DIAGNOSTIC_VALUES_LIST
#define COMBINED_DIAGNOSTIC_VALUES_LIST(X)
Simplified combined measurement registers used during tuning.
Definition tmc9660_param_mode_tmcl.hpp:4764
OVERCURRENT_THRESHOLD_LIST
#define OVERCURRENT_THRESHOLD_LIST(X)
Enumerates possible threshold values for overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1034
REFERENCE_SEARCH_STATUS_LIST
#define REFERENCE_SEARCH_STATUS_LIST(X)
Enumerates status codes for reference search state machine.
Definition tmc9660_param_mode_tmcl.hpp:4341
ADC_CONFIG_LIST
#define ADC_CONFIG_LIST(X)
Parameters for configuring ADCs for motor current measurement.
Definition tmc9660_param_mode_tmcl.hpp:1824
VGS_SHORT_ENABLE_LIST
#define VGS_SHORT_ENABLE_LIST(X)
Enumerates options for enabling or disabling VGS short protection.
Definition tmc9660_param_mode_tmcl.hpp:1353
HIBERNATION_WAKEUP_LIST
#define HIBERNATION_WAKEUP_LIST(X)
Parameters for configuring hibernation (low-power) and wakeup behavior.
Definition tmc9660_param_mode_tmcl.hpp:4546
REFERENCE_SWITCH_LATCH_SETTINGS_LIST
#define REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X)
Bitwise configuration for reference switch latch behavior.
Definition tmc9660_param_mode_tmcl.hpp:3401
ENABLE_DISABLE_LIST
#define ENABLE_DISABLE_LIST(X)
Generic enable/disable settings used by various parameters.
Definition tmc9660_param_mode_tmcl.hpp:2483
TORQUE_FLUX_CONTROL_LIST
#define TORQUE_FLUX_CONTROL_LIST(X)
Parameters for configuring torque and flux control loops.
Definition tmc9660_param_mode_tmcl.hpp:2595
UNDERVOLTAGE_LEVEL_LIST
#define UNDERVOLTAGE_LEVEL_LIST(X)
Enumerates possible levels for undervoltage protection.
Definition tmc9660_param_mode_tmcl.hpp:1223
PWM_OUTPUT_POLARITY_LIST
#define PWM_OUTPUT_POLARITY_LIST(X)
Table — PWM Output Polarity:
Definition tmc9660_param_mode_tmcl.hpp:714
BRAKE_CHOPPER_LIST
#define BRAKE_CHOPPER_LIST(X)
Parameters for configuring the brake chopper functionality.
Definition tmc9660_param_mode_tmcl.hpp:4056
MOTOR_TYPE_LIST
#define MOTOR_TYPE_LIST(X)
Enumerates supported motor types.
Definition tmc9660_param_mode_tmcl.hpp:1535
ACCELERATION_FF_SHIFT_LIST
#define ACCELERATION_FF_SHIFT_LIST(X)
Enumerates shift values for acceleration feedforward.
Definition tmc9660_param_mode_tmcl.hpp:2980
CSA_GAIN_LIST
#define CSA_GAIN_LIST(X)
Enumerates current sense amplifier gain settings.
Definition tmc9660_param_mode_tmcl.hpp:1930
HEARTBEAT_MONITORING_LIST
#define HEARTBEAT_MONITORING_LIST(X)
Parameters for configuring heartbeat monitoring.
Definition tmc9660_param_mode_tmcl.hpp:3950
OVERCURRENT_PROTECTION_LIST
#define OVERCURRENT_PROTECTION_LIST(X)
Parameters for configuring gate driver overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:935
EVENT_STOP_SETTINGS_LIST
#define EVENT_STOP_SETTINGS_LIST(X)
Bitwise configuration for stop conditions.
Definition tmc9660_param_mode_tmcl.hpp:3456
ADC_INVERSION_LIST
#define ADC_INVERSION_LIST(X)
Enumerates ADC inversion settings.
Definition tmc9660_param_mode_tmcl.hpp:2037
BOOTSTRAP_CURRENT_LIMIT_LIST
#define BOOTSTRAP_CURRENT_LIMIT_LIST(X)
Enumerates possible values for BOOTSTRAP_CURRENT_LIMIT (45–391mA).
Definition tmc9660_param_mode_tmcl.hpp:872
MOTOR_CONFIG_LIST
#define MOTOR_CONFIG_LIST(X)
Parameters for configuring motor characteristics and drive settings.
Definition tmc9660_param_mode_tmcl.hpp:1490
TEMPERATURE_PROTECTION_LIST
#define TEMPERATURE_PROTECTION_LIST(X)
Parameters for configuring temperature protection using external and internal sensors.
Definition tmc9660_param_mode_tmcl.hpp:3881
RAMDEBUG_STATE_LIST
#define RAMDEBUG_STATE_LIST(X)
Values returned by ::RamDebugType::GET_STATE.
Definition tmc9660_param_mode_tmcl.hpp:381
UNDERVOLTAGE_PROTECTION_LIST
#define UNDERVOLTAGE_PROTECTION_LIST(X)
Parameters for configuring undervoltage lockout (UVLO) protection.
Definition tmc9660_param_mode_tmcl.hpp:1167
WAIT_CONDITION_LIST
#define WAIT_CONDITION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:233
GATE_DRIVER_LIST
#define GATE_DRIVER_LIST(X)
Parameters for gate driver timer and current settings (Table 20).
Definition tmc9660_param_mode_tmcl.hpp:662
HEARTBEAT_MONITORING_CONFIG_LIST
#define HEARTBEAT_MONITORING_CONFIG_LIST(X)
Enumerates heartbeat monitoring interface selection.
Definition tmc9660_param_mode_tmcl.hpp:3992
MECHANICAL_BRAKE_LIST
#define MECHANICAL_BRAKE_LIST(X)
Parameters for controlling an external mechanical brake.
Definition tmc9660_param_mode_tmcl.hpp:4127
JUMP_CONDITION_LIST
#define JUMP_CONDITION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:203
PWM_SWITCHING_SCHEME_LIST
#define PWM_SWITCHING_SCHEME_LIST(X)
Enumerates PWM switching schemes.
Definition tmc9660_param_mode_tmcl.hpp:1602
REFERENCE_SWITCH_POLARITY_SWAP_LIST
#define REFERENCE_SWITCH_POLARITY_SWAP_LIST(X)
Bitwise configuration for reference switch polarity and swapping.
Definition tmc9660_param_mode_tmcl.hpp:3338
ABN_INIT_STATE_LIST
#define ABN_INIT_STATE_LIST(X)
Enumerates ABN encoder initialization states.
Definition tmc9660_param_mode_tmcl.hpp:2303
GENERAL_ERROR_FLAGS_LIST
#define GENERAL_ERROR_FLAGS_LIST(X)
Enumerates general error flags for GENERAL_ERROR_FLAGS.
Definition tmc9660_param_mode_tmcl.hpp:4989
CURRENT_PI_NORMALIZATION_LIST
#define CURRENT_PI_NORMALIZATION_LIST(X)
Normalization format for current PI controller output.
Definition tmc9660_param_mode_tmcl.hpp:2689
GLOBAL_PARAM_BANK3_LIST
#define GLOBAL_PARAM_BANK3_LIST(X)
Timer periods and input-trigger transitions for scripting interrupts.
Definition tmc9660_param_mode_tmcl.hpp:511
OVERCURRENT_ENABLE_LIST
#define OVERCURRENT_ENABLE_LIST(X)
Enumerates options for enabling or disabling overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:988
CALC_OPERATION_LIST
#define CALC_OPERATION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:172
RAMDEBUG_TYPE_LIST
#define RAMDEBUG_TYPE_LIST(X)
TYPE field values when Operation::RamDebug is issued.
Definition tmc9660_param_mode_tmcl.hpp:333
ADC_STATUS_FLAGS_LIST
#define ADC_STATUS_FLAGS_LIST(X)
Bit flags reported via parameter ADC_STATUS_FLAGS.
Definition tmc9660_param_mode_tmcl.hpp:5142
VGS_BLANKING_TIME_LIST
#define VGS_BLANKING_TIME_LIST(X)
Enumerates possible blanking times for VGS short protection.
Definition tmc9660_param_mode_tmcl.hpp:1387
BIQUAD_FILTER_ENABLE_LIST
#define BIQUAD_FILTER_ENABLE_LIST(X)
Enumerates enable/disable options for biquad filters.
Definition tmc9660_param_mode_tmcl.hpp:3590
GATE_CURRENT_SINK_LIST
#define GATE_CURRENT_SINK_LIST(X)
Enumerates possible values for UVW_SINK_CURRENT and Y2_SINK_CURRENT (50–2000mA).
Definition tmc9660_param_mode_tmcl.hpp:760
BIQUAD_FILTER_LIST
#define BIQUAD_FILTER_LIST(X)
Parameters for configuring biquad filters for torque and velocity control loops.
Definition tmc9660_param_mode_tmcl.hpp:3540
VDS_USAGE_LIST
#define VDS_USAGE_LIST(X)
Enumerates options for VDS measurement usage in overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1124
REFERENCE_SEARCH_LIST
#define REFERENCE_SEARCH_LIST(X)
Parameters for configuring automatic homing/reference search routines.
Definition tmc9660_param_mode_tmcl.hpp:4199
SPI_ENCODER_TRANSFER_LIST
#define SPI_ENCODER_TRANSFER_LIST(X)
Enumerates SPI encoder transfer modes.
Definition tmc9660_param_mode_tmcl.hpp:2416
REFERENCE_SWITCH_ENABLE_LIST
#define REFERENCE_SWITCH_ENABLE_LIST(X)
Bitwise enable for stopping when reference switch input is triggered.
Definition tmc9660_param_mode_tmcl.hpp:3283
UNDERVOLTAGE_ENABLE_LIST
#define UNDERVOLTAGE_ENABLE_LIST(X)
Enumerates options for enabling or disabling undervoltage protection.
Definition tmc9660_param_mode_tmcl.hpp:1270
POSITION_CONTROL_LIST
#define POSITION_CONTROL_LIST(X)
Parameters for configuring position control and ramping.
Definition tmc9660_param_mode_tmcl.hpp:3053
ADC_MAPPING_LIST
#define ADC_MAPPING_LIST(X)
Enumerates ADC mapping options for motor phases.
Definition tmc9660_param_mode_tmcl.hpp:2003
VELOCITY_CONTROL_LIST
#define VELOCITY_CONTROL_LIST(X)
Parameters for configuring velocity control and ramping.
Definition tmc9660_param_mode_tmcl.hpp:2781
GATE_DRIVER_ERROR_FLAGS_LIST
#define GATE_DRIVER_ERROR_FLAGS_LIST(X)
Enumerates gate driver error flags for GDRV_ERROR_FLAGS.
Definition tmc9660_param_mode_tmcl.hpp:5067
CSA_FILTER_LIST
#define CSA_FILTER_LIST(X)
Enumerates current sense amplifier filter settings.
Definition tmc9660_param_mode_tmcl.hpp:1967
VELOCITY_METER_MODE_LIST
#define VELOCITY_METER_MODE_LIST(X)
Enumerates velocity meter modes.
Definition tmc9660_param_mode_tmcl.hpp:2939
FEEDBACK_SENSOR_CONFIG_LIST
#define FEEDBACK_SENSOR_CONFIG_LIST(X)
Parameters for configuring feedback sensors (ABN, Hall, SPI encoders).
Definition tmc9660_param_mode_tmcl.hpp:2181
STEP_DIR_LIST
#define STEP_DIR_LIST(X)
Parameters for configuring the STEP/DIR target movement interface.
Definition tmc9660_param_mode_tmcl.hpp:4416
REPLY_CODE_LIST
#define REPLY_CODE_LIST(X)
Status codes returned in the status byte of every TMCL reply.
Definition tmc9660_param_mode_tmcl.hpp:279
REFERENCE_SEARCH_COMMAND_LIST
#define REFERENCE_SEARCH_COMMAND_LIST(X)
Enumerates TMCL RFS (13) command types for reference search.
Definition tmc9660_param_mode_tmcl.hpp:4291