HF-TMC9660 Driver 0.1.0-dev
Hardware Agnostic C++ Driver for the TMC9660
Loading...
Searching...
No Matches
tmc9660_param_mode_tmcl.hpp
Go to the documentation of this file.
1
7// clang-format off
8//====================================================================================================================
9// @file tmc9660_param_mode_tmcl.hpp
10// @brief Enumerations and helpers for **TMCL® operation & reply codes** when the TMC9660 is used
11// in *Parameter Mode*.
12//
13// This file provides comprehensive TMCL command definitions, parameter enumerations,
14// and helper structures for the TMC9660 motor driver in parameter mode operation.
15// It includes all operation codes, parameter definitions, and reply structures
16// needed for complete motor control functionality.
17//
18// @defgroup TMC9660_TMCL TMCL Command Interface
19// @brief TMCL operation codes and command structures
20//
21// @defgroup TMC9660_TMCLParameters TMCL Parameters
22// @brief Parameter definitions for motor control and system configuration
23//
24// @defgroup TMC9660_TMCLReplies TMCL Reply Structures
25// @brief Reply structures and status codes for TMCL commands
26//
27// @defgroup TMC9660_TMCLTypes TMCL Type Definitions
28// @brief Enums and type definitions for TMCL operations
29//
30// --------------------------------------------------------------------------------------------------
31// © 2025 <Nebiyu Tadesse>. Released under the GNU GPL V3 License.
32//====================================================================================================================
33#pragma once
34#include <cstdint>
35
45namespace tmc9660::tmcl {
46
47
49// //
50// ████████╗███╗ ███╗ ██████╗██╗ █████╗ ██████╗ ██╗ //
51// ╚══██╔══╝████╗ ████║██╔════╝██║ ██╔══██╗██╔══██╗██║ //
52// ██║ ██╔████╔██║██║ ██║ ███████║██████╔╝██║ //
53// ██║ ██║╚██╔╝██║██║ ██║ ██╔══██║██╔═══╝ ██║ //
54// ██║ ██║ ╚═╝ ██║╚██████╗███████╗ ██║ ██║██║ ██║ //
55// ╚═╝ ╚═╝ ╚═╝ ╚═════╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ //
56// //
57//==================================================================================================================//
58// TMCL API SECTION //
59//==================================================================================================================//
61
63// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
64// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
65// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
67
68//--------------------------------------
69// TMCL operation codes (Table 18)
70//--------------------------------------
131#define OP_LIST(X) \
132 X(MST, 3, ) \
133 X(SAP, 5, ) \
134 X(GAP, 6, ) \
135 X(STAP, 7, ) \
136 X(SGP, 9, ) \
137 X(GGP, 10, ) \
138 X(RFS, 13, ) \
139 X(SIO, 14, ) \
140 X(GIO, 15, ) \
141 X(CALC, 19, ) \
142 X(COMP, 20, ) \
143 X(JC, 21, ) \
144 X(JA, 22, ) \
145 X(CSUB, 23, ) \
146 X(RSUB, 24, ) \
147 X(EI, 25, ) \
148 X(DI, 26, ) \
149 X(WAIT, 27, ) \
150 X(STOP, 28, ) \
151 X(CALCX, 33, ) \
152 X(AAP, 34, ) \
153 X(AGP, 35, ) \
154 X(CLE, 36, ) \
155 X(VECT, 37, ) \
156 X(RETI, 38, ) \
157 X(CALCVV, 40, ) \
158 X(CALCVA, 41, ) \
159 X(CALCAV, 42, ) \
160 X(CALCVX, 43, ) \
161 X(CALCXV, 44, ) \
162 X(CALCV, 45, ) \
163 X(RST, 48, ) \
164 X(DJNZ, 49, ) \
165 X(SIV, 55, ) \
166 X(GIV, 56, ) \
167 X(AIV, 57, ) \
168 X(ApplStop, 128, ) \
169 X(ApplRun, 129, ) \
170 X(ApplStep, 130, ) \
171 X(ApplReset, 131, ) \
172 X(DownloadStart, 132, ) \
173 X(DownloadEnd, 133, ) \
174 X(ReadMem, 134, ) \
175 X(GetStatusScript, 135, ) \
176 X(GetVersion, 136, ) \
177 X(FactoryDefault, 137, ) \
178 X(Breakpoint, 141, ) \
179 X(RamDebug, 142, ) \
180 X(GetInfo, 157, ) \
181 X(Boot, 242, )
182
183enum class Op : std::uint8_t {
184 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
185 OP_LIST(X)
186 #undef X
187};
188
189inline const char* to_string(Op op) {
190 switch(op) {
191 #define X(NAME, VALUE, DOC) case Op::NAME: return #NAME;
192 OP_LIST(X)
193 #undef X
194 default: return "UNKNOWN";
195 }
196}
197#undef OP_LIST
198
199//--------------------------------------
200// Arithmetic operation types for CALC
201//--------------------------------------
202#define CALC_OPERATION_LIST(X) \
203 X(CALC_ADD, 0, ) \
204 X(CALC_SUB, 1, ) \
205 X(CALC_MUL, 2, ) \
206 X(CALC_DIV, 3, ) \
207 X(CALC_MOD, 4, ) \
208 X(CALC_AND, 5, ) \
209 X(CALC_OR, 6, ) \
210 X(CALC_XOR, 7, ) \
211 X(CALC_NOT, 8, ) \
212 X(CALC_LOAD,9, )
213
214enum class CalcOperation : std::uint8_t {
215 #define X(NAME, VALUE, DOC) NAME = VALUE,
216 CALC_OPERATION_LIST(X)
217 #undef X
218};
219
220inline const char* to_string(CalcOperation op) {
221 switch(op) {
222 #define X(NAME, VALUE, DOC) case CalcOperation::NAME: return #NAME;
223 CALC_OPERATION_LIST(X)
224 #undef X
225 default: return "UNKNOWN";
226 }
227}
228#undef CALC_OPERATION_LIST
229
230//--------------------------------------
231// Conditional jump conditions for JC
232//--------------------------------------
233#define JUMP_CONDITION_LIST(X) \
234 X(JC_ZERO, 0, ) \
235 X(JC_NOT_ZERO, 1, ) \
236 X(JC_EQUAL, 2, ) \
237 X(JC_NOT_EQUAL, 3, ) \
238 X(JC_GREATER, 4, ) \
239 X(JC_GREATER_EQ, 5, ) \
240 X(JC_LOWER, 6, ) \
241 X(JC_LOWER_EQ, 7, ) \
242 X(JC_TIMEOUT, 8, )
243
244enum class JumpCondition : std::uint8_t {
245 #define X(NAME, VALUE, DOC) NAME = VALUE,
246 JUMP_CONDITION_LIST(X)
247 #undef X
248};
249
250inline const char* to_string(JumpCondition c) {
251 switch(c) {
252 #define X(NAME, VALUE, DOC) case JumpCondition::NAME: return #NAME;
253 JUMP_CONDITION_LIST(X)
254 #undef X
255 default: return "UNKNOWN";
256 }
257}
258#undef JUMP_CONDITION_LIST
259
260//--------------------------------------
261// WAIT event conditions
262//--------------------------------------
263#define WAIT_CONDITION_LIST(X) \
264 X(WAIT_TIME, 0, ) \
265 X(WAIT_RFS, 4, ) \
266 X(WAIT_LATCH, 5, ) \
267 X(WAIT_VEL_REACHED, 6, ) \
268 X(WAIT_POS_REACHED, 7, ) \
269 X(WAIT_STOP_LEFT, 8, ) \
270 X(WAIT_STOP_RIGHT, 9, ) \
271 X(WAIT_STOP_HOME, 10, )
272
273enum class WaitCondition : std::uint8_t {
274 #define X(NAME, VALUE, DOC) NAME = VALUE,
275 WAIT_CONDITION_LIST(X)
276 #undef X
277};
278
279inline const char* to_string(WaitCondition w) {
280 switch(w) {
281 #define X(NAME, VALUE, DOC) case WaitCondition::NAME: return #NAME;
282 WAIT_CONDITION_LIST(X)
283 #undef X
284 default: return "UNKNOWN";
285 }
286}
287#undef WAIT_CONDITION_LIST
288
289//--------------------------------------
290// TMCL reply codes (Table 19)
291//--------------------------------------
309#define REPLY_CODE_LIST(X) \
310 X(REPLY_OK, 100, ) \
311 X(REPLY_CMD_LOADED, 101, ) \
312 X(REPLY_CHKERR, 1, ) \
313 X(REPLY_INVALID_CMD, 2, ) \
314 X(REPLY_WRONG_TYPE, 3, ) \
315 X(REPLY_INVALID_VALUE, 4, ) \
316 X(REPLY_CMD_NOT_AVAILABLE, 6, ) \
317 X(REPLY_CMD_LOAD_ERROR, 7, ) \
318 X(REPLY_MAX_EXCEEDED, 9, ) \
319 X(REPLY_DOWNLOAD_NOT_POSSIBLE, 10, )
320
321enum class ReplyCode : std::uint8_t {
322 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
323 REPLY_CODE_LIST(X)
324 #undef X
325};
326
327inline const char* to_string(ReplyCode rc) {
328 switch(rc) {
329 #define X(NAME, VALUE, DOC) case ReplyCode::NAME: return #NAME;
330 REPLY_CODE_LIST(X)
331 #undef X
332 default: return "UNKNOWN";
333 }
334}
335#undef REPLY_CODE_LIST
336
337//--------------------------------------
338// RAMDebug sub‑commands / type codes (Table 16)
339//--------------------------------------
363#define RAMDEBUG_TYPE_LIST(X) \
364 X(INITIALISE_RESET, 0, ) \
365 X(SET_SAMPLE_COUNT, 1, ) \
366 X(SET_PRESCALER, 3, ) \
367 X(SET_CHANNEL, 4, ) \
368 X(SET_TRIGGER_CHANNEL, 5, ) \
369 X(SET_TRIGGER_MASK_SHIFT, 6, ) \
370 X(ENABLE_TRIGGER, 7, ) \
371 X(GET_STATE, 8, ) \
372 X(READ_SAMPLE, 9, ) \
373 X(GET_INFO, 10, ) \
374 X(GET_CHANNEL_TYPE, 11, ) \
375 X(GET_CHANNEL_ADDRESS, 12, ) \
376 X(SET_PRETRIGGER_COUNT, 13, ) \
377 X(GET_PRETRIGGER_COUNT, 14, )
378
379enum class RamDebugType : std::uint8_t {
380 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
381 RAMDEBUG_TYPE_LIST(X)
382 #undef X
383};
384
385inline const char* to_string(RamDebugType t) {
386 switch(t) {
387 #define X(NAME, VALUE, DOC) case RamDebugType::NAME: return #NAME;
388 RAMDEBUG_TYPE_LIST(X)
389 #undef X
390 default: return "UNKNOWN";
391 }
392}
393#undef RAMDEBUG_TYPE_LIST
394
395//--------------------------------------
396// RAMDebug state machine (Table 17)
397//--------------------------------------
411#define RAMDEBUG_STATE_LIST(X) \
412 X(IDLE, 0, ) \
413 X(TRIGGER, 1, ) \
414 X(CAPTURE, 2, ) \
415 X(COMPLETE, 3, ) \
416 X(PRETRIGGER, 4, )
417
418enum class RamDebugState : std::uint8_t {
419 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
420 RAMDEBUG_STATE_LIST(X)
421 #undef X
422};
423
424inline const char* to_string(RamDebugState s) {
425 switch(s) {
426 #define X(NAME, VALUE, DOC) case RamDebugState::NAME: return #NAME;
427 RAMDEBUG_STATE_LIST(X)
428 #undef X
429 default: return "UNKNOWN";
430 }
431}
432#undef RAMDEBUG_STATE_LIST
433
434
436// //
437// ██████╗ ██╗ ██████╗ ██████╗ █████╗ ██╗ ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
438// ██╔════╝ ██║ ██╔═══██╗██╔══██╗██╔══██╗██║ ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
439// ██║ ███╗██║ ██║ ██║██████╔╝███████║██║ ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
440// ██║ ██║██║ ██║ ██║██╔══██╗██╔══██║██║ ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
441// ╚██████╔╝███████╗╚██████╔╝██████╔╝██║ ██║███████╗ ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
442// ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
443// //
444//==================================================================================================================//
445// GLOBAL PARAMETERS SECTION //
446//==================================================================================================================//
448
450// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
451// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
452// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
454
455//--------------------------------------
456// Global Parameters – Bank 0 (System Settings)
457//--------------------------------------
463#define GLOBAL_PARAM_BANK0_LIST(X) \
464 X(SERIAL_ADDRESS, 1, ) \
465 X(SERIAL_HOST_ADDRESS, 2, ) \
466 X(HEARTBEAT_MONITORING_CONFIG, 3, ) \
467 X(HEARTBEAT_MONITORING_TIMEOUT, 4, ) \
468 X(IO_DIRECTION_MASK, 5, ) \
469 X(IO_INPUT_PULLUP_PULLDOWN_ENABLE_MASK, 6, ) \
470 X(IO_INPUT_PULLUP_PULLDOWN_DIRECTION_MASK, 7, ) \
471 X(WAKE_PIN_CONTROL_ENABLE, 10, ) \
472 X(GO_TO_TIMEOUT_POWER_DOWN_STATE, 11, ) \
473 X(MAIN_LOOPS, 12, ) \
474 X(TORQUE_LOOPS, 13, ) \
475 X(VELOCITY_LOOPS, 14, ) \
476 X(AUTO_START_ENABLE, 77, ) \
477 X(CLEAR_USER_VARIABLES, 85, )
478
479enum class GlobalParamBank0 : std::uint16_t {
480 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
481 GLOBAL_PARAM_BANK0_LIST(X)
482 #undef X
483};
484
485inline const char* to_string(GlobalParamBank0 p) {
486 switch(p) {
487 #define X(NAME, VALUE, DOC) case GlobalParamBank0::NAME: return #NAME;
488 GLOBAL_PARAM_BANK0_LIST(X)
489 #undef X
490 default: return "UNKNOWN";
491 }
492}
493#undef GLOBAL_PARAM_BANK0_LIST
494
495//--------------------------------------
496// Global Parameters – Bank 2 (User Variables)
497//--------------------------------------
501#define GLOBAL_PARAM_BANK2_LIST(X) \
502 X(USER_VARIABLE_0, 0, ) \
503 X(USER_VARIABLE_1, 1, ) \
504 X(USER_VARIABLE_2, 2, ) \
505 X(USER_VARIABLE_3, 3, ) \
506 X(USER_VARIABLE_4, 4, ) \
507 X(USER_VARIABLE_5, 5, ) \
508 X(USER_VARIABLE_6, 6, ) \
509 X(USER_VARIABLE_7, 7, ) \
510 X(USER_VARIABLE_8, 8, ) \
511 X(USER_VARIABLE_9, 9, ) \
512 X(USER_VARIABLE_10, 10, ) \
513 X(USER_VARIABLE_11, 11, ) \
514 X(USER_VARIABLE_12, 12, ) \
515 X(USER_VARIABLE_13, 13, ) \
516 X(USER_VARIABLE_14, 14, ) \
517 X(USER_VARIABLE_15, 15, )
518
519enum class GlobalParamBank2 : std::uint16_t {
520 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
521 GLOBAL_PARAM_BANK2_LIST(X)
522 #undef X
523};
524
525inline const char* to_string(GlobalParamBank2 p) {
526 switch(p) {
527 #define X(NAME, VALUE, DOC) case GlobalParamBank2::NAME: return #NAME;
528 GLOBAL_PARAM_BANK2_LIST(X)
529 #undef X
530 default: return "UNKNOWN";
531 }
532}
533#undef GLOBAL_PARAM_BANK2_LIST
534
535//--------------------------------------
536// Global Parameters – Bank 3 (Interrupt & Trigger Configuration)
537//--------------------------------------
541#define GLOBAL_PARAM_BANK3_LIST(X) \
542 X(TIMER_0_PERIOD, 0, ) \
543 X(TIMER_1_PERIOD, 1, ) \
544 X(TIMER_2_PERIOD, 2, ) \
545 X(STOP_LEFT_TRIGGER_TRANSITION, 10, ) \
546 X(STOP_RIGHT_TRIGGER_TRANSITION, 11, ) \
547 X(HOME_TRIGGER_TRANSITION, 12, ) \
548 X(INPUT_0_TRIGGER_TRANSITION, 13, ) \
549 X(INPUT_1_TRIGGER_TRANSITION, 14, ) \
550 X(INPUT_2_TRIGGER_TRANSITION, 15, ) \
551 X(INPUT_3_TRIGGER_TRANSITION, 16, ) \
552 X(INPUT_4_TRIGGER_TRANSITION, 17, ) \
553 X(INPUT_5_TRIGGER_TRANSITION, 18, ) \
554 X(INPUT_6_TRIGGER_TRANSITION, 19, ) \
555 X(INPUT_7_TRIGGER_TRANSITION, 20, ) \
556 X(INPUT_8_TRIGGER_TRANSITION, 21, ) \
557 X(INPUT_9_TRIGGER_TRANSITION, 22, ) \
558 X(INPUT_10_TRIGGER_TRANSITION, 23, ) \
559 X(INPUT_11_TRIGGER_TRANSITION, 24, ) \
560 X(INPUT_12_TRIGGER_TRANSITION, 25, ) \
561 X(INPUT_13_TRIGGER_TRANSITION, 26, ) \
562 X(INPUT_14_TRIGGER_TRANSITION, 27, ) \
563 X(INPUT_15_TRIGGER_TRANSITION, 28, ) \
564 X(INPUT_16_TRIGGER_TRANSITION, 29, ) \
565 X(INPUT_17_TRIGGER_TRANSITION, 30, ) \
566 X(INPUT_18_TRIGGER_TRANSITION, 31, )
567
568enum class GlobalParamBank3 : std::uint16_t {
569 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
570 GLOBAL_PARAM_BANK3_LIST(X)
571 #undef X
572};
573
574inline const char* to_string(GlobalParamBank3 p) {
575 switch(p) {
576 #define X(NAME, VALUE, DOC) case GlobalParamBank3::NAME: return #NAME;
577 GLOBAL_PARAM_BANK3_LIST(X)
578 #undef X
579 default: return "UNKNOWN";
580 }
581}
582#undef GLOBAL_PARAM_BANK3_LIST
583
585// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
586// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
587// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
589
592//--------------------------------------
593// Trigger Transition Options
594//--------------------------------------
605#define TRIGGER_TRANSITION_LIST(X) \
606 X(OFF, 0, ) \
607 X(RISING, 1, ) \
608 X(FALLING, 2, ) \
609 X(BOTH, 3, )
610
611enum class TriggerTransition : uint8_t {
612 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
613 TRIGGER_TRANSITION_LIST(X)
614 #undef X
615};
616
617inline const char* to_string(TriggerTransition e) {
618 switch(e) {
619 #define X(NAME, VALUE, DOC) case TriggerTransition::NAME: return #NAME;
620 TRIGGER_TRANSITION_LIST(X)
621 #undef X
622 default: return "UNKNOWN";
623 }
624}
625#undef TRIGGER_TRANSITION_LIST
627
629// //
630// ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
631// ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
632// ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
633// ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
634// ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
635// ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
636// //
637//==================================================================================================================//
638// PARAMETERS //
639//==================================================================================================================//
641
643// //
644// ██████╗ █████╗ ████████╗███████╗ ██████╗ ██████╗ ██╗██╗ ██╗███████╗██████╗ ███████╗ //
645// ██╔════╝ ██╔══██╗╚══██╔══╝██╔════╝ ██╔══██╗██╔══██╗██║██║ ██║██╔════╝██╔══██╗██╔════╝ //
646// ██║ ███╗███████║ ██║ █████╗ ██║ ██║██████╔╝██║██║ ██║█████╗ ██████╔╝███████╗ //
647// ██║ ██║██╔══██║ ██║ ██╔══╝ ██║ ██║██╔══██╗██║╚██╗ ██╔╝██╔══╝ ██╔══██╗╚════██║ //
648// ╚██████╔╝██║ ██║ ██║ ███████╗ ██████╔╝██║ ██║██║ ╚████╔╝ ███████╗██║ ██║███████║ //
649// ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚══════╝ //
650// //
651//==================================================================================================================//
652// GATE DRIVER SECTION //
653//==================================================================================================================//
655
657// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
658// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
659// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
661
662//--------------------------------------
663// Gate Driver Parameters (Table 20)
664//--------------------------------------
692#define GATE_DRIVER_LIST(X) \
693 X(PWM_L_OUTPUT_POLARITY, 233, ) \
694 X(PWM_H_OUTPUT_POLARITY, 234, ) \
695 X(BREAK_BEFORE_MAKE_TIME_LOW_UVW, 235, ) \
696 X(BREAK_BEFORE_MAKE_TIME_HIGH_UVW, 236, ) \
697 X(BREAK_BEFORE_MAKE_TIME_LOW_Y2, 237, ) \
698 X(BREAK_BEFORE_MAKE_TIME_HIGH_Y2, 238, ) \
699 X(USE_ADAPTIVE_DRIVE_TIME_UVW, 239, ) \
700 X(USE_ADAPTIVE_DRIVE_TIME_Y2, 240, ) \
701 X(DRIVE_TIME_SINK_UVW, 241, ) \
702 X(DRIVE_TIME_SOURCE_UVW, 242, ) \
703 X(DRIVE_TIME_SINK_Y2, 243, ) \
704 X(DRIVE_TIME_SOURCE_Y2, 244, ) \
705 X(UVW_SINK_CURRENT, 245, ) \
706 X(UVW_SOURCE_CURRENT, 246, ) \
707 X(Y2_SINK_CURRENT, 247, ) \
708 X(Y2_SOURCE_CURRENT, 248, ) \
709 X(BOOTSTRAP_CURRENT_LIMIT, 249, )
710
711enum class GateDriver : uint16_t {
712 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
713 GATE_DRIVER_LIST(X)
714 #undef X
715};
716
717inline const char* to_string(GateDriver gd) {
718 switch (gd) {
719 #define X(NAME, VALUE, DOC) case GateDriver::NAME: return #NAME;
720 GATE_DRIVER_LIST(X)
721 #undef X
722 default: return "UNKNOWN";
723 }
724}
725
726
728// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
729// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
730// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
732//--------------------------------------
733// PWM Output Polarity (Table)
734//--------------------------------------
744#define PWM_OUTPUT_POLARITY_LIST(X) \
745 X(ACTIVE_HIGH, 0, ) \
746 X(ACTIVE_LOW, 1, )
747
748enum class PwmOutputPolarity : std::uint8_t {
749 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
750 PWM_OUTPUT_POLARITY_LIST(X)
751 #undef X
752};
753
754inline const char* to_string(PwmOutputPolarity p) {
755 switch(p) {
756 #define X(NAME, VALUE, DOC) case PwmOutputPolarity::NAME: return #NAME;
757 PWM_OUTPUT_POLARITY_LIST(X)
758 #undef X
759 default: return "UNKNOWN";
760 }
761}
762#undef PWM_OUTPUT_POLARITY_LIST
763
764//--------------------------------------
765// Gate Current Sink (Table)
766//--------------------------------------
790#define GATE_CURRENT_SINK_LIST(X) \
791 X(CUR_50_MA, 0, ) \
792 X(CUR_100_MA, 1, ) \
793 X(CUR_160_MA, 2, ) \
794 X(CUR_210_MA, 3, ) \
795 X(CUR_270_MA, 4, ) \
796 X(CUR_320_MA, 5, ) \
797 X(CUR_380_MA, 6, ) \
798 X(CUR_430_MA, 7, ) \
799 X(CUR_580_MA, 8, ) \
800 X(CUR_720_MA, 9, ) \
801 X(CUR_860_MA, 10, ) \
802 X(CUR_1000_MA, 11, ) \
803 X(CUR_1250_MA, 12, ) \
804 X(CUR_1510_MA, 13, ) \
805 X(CUR_1770_MA, 14, ) \
806 X(CUR_2000_MA, 15, )
807
808enum class GateCurrentSink : std::uint8_t {
809 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
810 GATE_CURRENT_SINK_LIST(X)
811 #undef X
812};
813
814inline const char* to_string(GateCurrentSink s) {
815 switch(s) {
816 #define X(NAME, VALUE, DOC) case GateCurrentSink::NAME: return #NAME;
817 GATE_CURRENT_SINK_LIST(X)
818 #undef X
819 default: return "UNKNOWN";
820 }
821}
822#undef GATE_CURRENT_SINK_LIST
823
824//--------------------------------------
825// Gate Current Source (Table)
826//--------------------------------------
850#define GATE_CURRENT_SOURCE_LIST(X) \
851 X(CUR_25_MA, 0, ) \
852 X(CUR_50_MA, 1, ) \
853 X(CUR_80_MA, 2, ) \
854 X(CUR_105_MA, 3, ) \
855 X(CUR_135_MA, 4, ) \
856 X(CUR_160_MA, 5, ) \
857 X(CUR_190_MA, 6, ) \
858 X(CUR_215_MA, 7, ) \
859 X(CUR_290_MA, 8, ) \
860 X(CUR_360_MA, 9, ) \
861 X(CUR_430_MA, 10, ) \
862 X(CUR_500_MA, 11, ) \
863 X(CUR_625_MA, 12, ) \
864 X(CUR_755_MA, 13, ) \
865 X(CUR_855_MA, 14, ) \
866 X(CUR_1000_MA, 15, )
867
868enum class GateCurrentSource : std::uint8_t {
869 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
870 GATE_CURRENT_SOURCE_LIST(X)
871 #undef X
872};
873
874inline const char* to_string(GateCurrentSource s) {
875 switch(s) {
876 #define X(NAME, VALUE, DOC) case GateCurrentSource::NAME: return #NAME;
877 GATE_CURRENT_SOURCE_LIST(X)
878 #undef X
879 default: return "UNKNOWN";
880 }
881}
882#undef GATE_CURRENT_SOURCE_LIST
883
884//--------------------------------------
885// Bootstrap Current Limit (Table)
886//--------------------------------------
902#define BOOTSTRAP_CURRENT_LIMIT_LIST(X) \
903 X(CUR_45_MA, 0, ) \
904 X(CUR_91_MA, 1, ) \
905 X(CUR_141_MA, 2, ) \
906 X(CUR_191_MA, 3, ) \
907 X(CUR_267_MA, 4, ) \
908 X(CUR_292_MA, 5, ) \
909 X(CUR_341_MA, 6, ) \
910 X(CUR_391_MA, 7, )
911
912enum class BootstrapCurrentLimit : std::uint8_t {
913 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
914 BOOTSTRAP_CURRENT_LIMIT_LIST(X)
915 #undef X
916};
917
918inline const char* to_string(BootstrapCurrentLimit s) {
919 switch(s) {
920 #define X(NAME, VALUE, DOC) case BootstrapCurrentLimit::NAME: return #NAME;
921 BOOTSTRAP_CURRENT_LIMIT_LIST(X)
922 #undef X
923 default: return "UNKNOWN";
924 }
925}
926#undef BOOTSTRAP_CURRENT_LIMIT_LIST
927
929// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
930// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
931// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
933
934//--------------------------------------
935// Gate Driver Overcurrent Protection
936//--------------------------------------
965#define OVERCURRENT_PROTECTION_LIST(X) \
966 X(UVW_LOW_SIDE_ENABLE, 254, ) \
967 X(UVW_HIGH_SIDE_ENABLE, 255, ) \
968 X(Y2_LOW_SIDE_ENABLE, 256, ) \
969 X(Y2_HIGH_SIDE_ENABLE, 257, ) \
970 X(UVW_LOW_SIDE_THRESHOLD, 258, ) \
971 X(UVW_HIGH_SIDE_THRESHOLD, 259, ) \
972 X(Y2_LOW_SIDE_THRESHOLD, 260, ) \
973 X(Y2_HIGH_SIDE_THRESHOLD, 261, ) \
974 X(UVW_LOW_SIDE_BLANKING, 262, ) \
975 X(UVW_HIGH_SIDE_BLANKING, 263, ) \
976 X(Y2_LOW_SIDE_BLANKING, 264, ) \
977 X(Y2_HIGH_SIDE_BLANKING, 265, ) \
978 X(UVW_LOW_SIDE_DEGLITCH, 266, ) \
979 X(UVW_HIGH_SIDE_DEGLITCH, 267, ) \
980 X(Y2_LOW_SIDE_DEGLITCH, 268, ) \
981 X(Y2_HIGH_SIDE_DEGLITCH, 269, ) \
982 X(UVW_LOW_SIDE_USE_VDS, 270, ) \
983 X(Y2_LOW_SIDE_USE_VDS, 271, )
984
985enum class OvercurrentProtection : uint16_t {
986 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
987 OVERCURRENT_PROTECTION_LIST(X)
988 #undef X
989};
990
991inline const char* to_string(OvercurrentProtection p) {
992 switch(p) {
993 #define X(NAME, VALUE, DOC) case OvercurrentProtection::NAME: return #NAME;
994 OVERCURRENT_PROTECTION_LIST(X)
995 #undef X
996 default: return "UNKNOWN";
997 }
998}
999
1001// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1002// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1003// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1005
1006//--------------------------------------
1007// Overcurrent Protection Enable/Disable
1008//--------------------------------------
1018#define OVERCURRENT_ENABLE_LIST(X) \
1019 X(DISABLED, 0, ) \
1020 X(ENABLED, 1, )
1021
1022enum class OvercurrentEnable : std::uint8_t {
1023 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1024 OVERCURRENT_ENABLE_LIST(X)
1025 #undef X
1026};
1027
1028inline const char* to_string(OvercurrentEnable e) {
1029 switch(e) {
1030 #define X(NAME, VALUE, DOC) case OvercurrentEnable::NAME: return #NAME;
1031 OVERCURRENT_ENABLE_LIST(X)
1032 #undef X
1033 default: return "UNKNOWN";
1034 }
1035}
1036#undef OVERCURRENT_ENABLE_LIST
1037
1038//--------------------------------------
1039// Overcurrent Protection Thresholds
1040//--------------------------------------
1073#define OVERCURRENT_THRESHOLD_LIST(X) \
1074 X(V_80_OR_63_MILLIVOLT, 0, ) \
1075 X(V_165_OR_125_MILLIVOLT, 1, ) \
1076 X(V_250_OR_187_MILLIVOLT, 2, ) \
1077 X(V_330_OR_248_MILLIVOLT, 3, ) \
1078 X(V_415_OR_312_MILLIVOLT, 4, ) \
1079 X(V_500_OR_374_MILLIVOLT, 5, ) \
1080 X(V_582_OR_434_MILLIVOLT, 6, ) \
1081 X(V_660_OR_504_MILLIVOLT, 7, ) \
1082 X(V_125_OR_705_MILLIVOLT, 8, ) \
1083 X(V_250_OR_940_MILLIVOLT, 9, ) \
1084 X(V_375_OR_1180_MILLIVOLT, 10, ) \
1085 X(V_500_OR_1410_MILLIVOLT, 11, ) \
1086 X(V_625_OR_1650_MILLIVOLT, 12, ) \
1087 X(V_750_OR_1880_MILLIVOLT, 13, ) \
1088 X(V_875_OR_2110_MILLIVOLT, 14, ) \
1089 X(V_1000_OR_2350_MILLIVOLT, 15, )
1090
1091enum class OvercurrentThreshold : std::uint8_t {
1092 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1093 OVERCURRENT_THRESHOLD_LIST(X)
1094 #undef X
1095};
1096
1097inline const char* to_string(OvercurrentThreshold t) {
1098 switch(t) {
1099 #define X(NAME, VALUE, DOC) case OvercurrentThreshold::NAME: return #NAME;
1100 OVERCURRENT_THRESHOLD_LIST(X)
1101 #undef X
1102 default: return "UNKNOWN";
1103 }
1104}
1105#undef OVERCURRENT_THRESHOLD_LIST
1106
1107//--------------------------------------
1108// Overcurrent Protection Blanking and Deglitch Times
1109//--------------------------------------
1125#define OVERCURRENT_TIMING_LIST(X) \
1126 X(OFF, 0, ) \
1127 X(T_0_25_MICROSEC, 1, ) \
1128 X(T_0_5_MICROSEC, 2, ) \
1129 X(T_1_MICROSEC, 3, ) \
1130 X(T_2_MICROSEC, 4, ) \
1131 X(T_4_MICROSEC, 5, ) \
1132 X(T_6_MICROSEC, 6, ) \
1133 X(T_8_MICROSEC, 7, )
1134
1135enum class OvercurrentTiming : std::uint8_t {
1136 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1137 OVERCURRENT_TIMING_LIST(X)
1138 #undef X
1139};
1140
1141inline const char* to_string(OvercurrentTiming t) {
1142 switch(t) {
1143 #define X(NAME, VALUE, DOC) case OvercurrentTiming::NAME: return #NAME;
1144 OVERCURRENT_TIMING_LIST(X)
1145 #undef X
1146 default: return "UNKNOWN";
1147 }
1148}
1149#undef OVERCURRENT_TIMING_LIST
1150
1151//--------------------------------------
1152// VDS Measurement Enable/Disable
1153//--------------------------------------
1163#define VDS_USAGE_LIST(X) \
1164 X(DISABLED, 0, ) \
1165 X(ENABLED, 1, )
1166
1167enum class VdsUsage : std::uint8_t {
1168 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1169 VDS_USAGE_LIST(X)
1170 #undef X
1171};
1172
1173inline const char* to_string(VdsUsage v) {
1174 switch(v) {
1175 #define X(NAME, VALUE, DOC) case VdsUsage::NAME: return #NAME;
1176 VDS_USAGE_LIST(X)
1177 #undef X
1178 default: return "UNKNOWN";
1179 }
1180}
1181#undef VDS_USAGE_LIST
1182
1184// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1185// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1186// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1188
1189//--------------------------------------
1190// Undervoltage Protection Parameters
1191//--------------------------------------
1206#define UNDERVOLTAGE_PROTECTION_LIST(X) \
1207 X(SUPPLY_LEVEL, 250, ) \
1208 X(VDRV_ENABLE, 251, ) \
1209 X(BST_UVW_ENABLE, 252, ) \
1210 X(BST_Y2_ENABLE, 253, )
1211
1212enum class UndervoltageProtection : uint16_t {
1213 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1214 UNDERVOLTAGE_PROTECTION_LIST(X)
1215 #undef X
1216};
1217
1218inline const char* to_string(UndervoltageProtection p) {
1219 switch(p) {
1220 #define X(NAME, VALUE, DOC) case UndervoltageProtection::NAME: return #NAME;
1221 UNDERVOLTAGE_PROTECTION_LIST(X)
1222 #undef X
1223 default: return "UNKNOWN";
1224 }
1225}
1226
1228// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1229// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1230// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1232
1233//--------------------------------------
1234// Undervoltage Protection Levels
1235//--------------------------------------
1262#define UNDERVOLTAGE_LEVEL_LIST(X) \
1263 X(DISABLED, 0, ) \
1264 X(LEVEL_0, 1, ) \
1265 X(LEVEL_1, 2, ) \
1266 X(LEVEL_2, 3, ) \
1267 X(LEVEL_3, 4, ) \
1268 X(LEVEL_4, 5, ) \
1269 X(LEVEL_5, 6, ) \
1270 X(LEVEL_6, 7, ) \
1271 X(LEVEL_7, 8, ) \
1272 X(LEVEL_8, 9, ) \
1273 X(LEVEL_9, 10, ) \
1274 X(LEVEL_10, 11, ) \
1275 X(LEVEL_11, 12, ) \
1276 X(LEVEL_12, 13, ) \
1277 X(LEVEL_13, 14, ) \
1278 X(LEVEL_14, 15, ) \
1279 X(LEVEL_15, 16, )
1280
1281enum class UndervoltageLevel : std::uint8_t {
1282 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1283 UNDERVOLTAGE_LEVEL_LIST(X)
1284 #undef X
1285};
1286
1287inline const char* to_string(UndervoltageLevel level) {
1288 switch(level) {
1289 #define X(NAME, VALUE, DOC) case UndervoltageLevel::NAME: return #NAME;
1290 UNDERVOLTAGE_LEVEL_LIST(X)
1291 #undef X
1292 default: return "UNKNOWN";
1293 }
1294}
1295#undef UNDERVOLTAGE_LEVEL_LIST
1296
1297//--------------------------------------
1298// Undervoltage Protection Enable/Disable
1299//--------------------------------------
1309#define UNDERVOLTAGE_ENABLE_LIST(X) \
1310 X(DISABLED, 0, ) \
1311 X(ENABLED, 1, )
1312
1313enum class UndervoltageEnable : std::uint8_t {
1314 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1315 UNDERVOLTAGE_ENABLE_LIST(X)
1316 #undef X
1317};
1318
1319inline const char* to_string(UndervoltageEnable enable) {
1320 switch(enable) {
1321 #define X(NAME, VALUE, DOC) case UndervoltageEnable::NAME: return #NAME;
1322 UNDERVOLTAGE_ENABLE_LIST(X)
1323 #undef X
1324 default: return "UNKNOWN";
1325 }
1326}
1327#undef UNDERVOLTAGE_ENABLE_LIST
1328
1330// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1331// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1332// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1334
1335//--------------------------------------
1336// Gate Short (VGS) Protection Parameters
1337//--------------------------------------
1345#define VGS_SHORT_PROTECTION_LIST(X) \
1346 X(UVW_LOW_SIDE_ON_ENABLE, 272, ) \
1347 X(UVW_LOW_SIDE_OFF_ENABLE, 273, ) \
1348 X(UVW_HIGH_SIDE_ON_ENABLE, 274, ) \
1349 X(UVW_HIGH_SIDE_OFF_ENABLE,275, ) \
1350 X(Y2_LOW_SIDE_ON_ENABLE, 276, ) \
1351 X(Y2_LOW_SIDE_OFF_ENABLE, 277, ) \
1352 X(Y2_HIGH_SIDE_ON_ENABLE, 278, ) \
1353 X(Y2_HIGH_SIDE_OFF_ENABLE, 279, ) \
1354 X(UVW_BLANKING, 280, ) \
1355 X(Y2_BLANKING, 281, ) \
1356 X(UVW_DEGLITCH, 282, ) \
1357 X(Y2_DEGLITCH, 283, )
1358
1359enum class VgsShortProtection : uint16_t {
1360 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1361 VGS_SHORT_PROTECTION_LIST(X)
1362 #undef X
1363};
1364
1365inline const char* to_string(VgsShortProtection p) {
1366 switch(p) {
1367 #define X(NAME, VALUE, DOC) case VgsShortProtection::NAME: return #NAME;
1368 VGS_SHORT_PROTECTION_LIST(X)
1369 #undef X
1370 default: return "UNKNOWN";
1371 }
1372}
1373
1375// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1376// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1377// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1379
1380//--------------------------------------
1381// VGS Protection Enable/Disable
1382//--------------------------------------
1392#define VGS_SHORT_ENABLE_LIST(X) \
1393 X(DISABLED, 0, ) \
1394 X(ENABLED, 1, )
1395
1396enum class VgsShortEnable : uint8_t {
1397 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1398 VGS_SHORT_ENABLE_LIST(X)
1399 #undef X
1400};
1401
1402inline const char* to_string(VgsShortEnable e) {
1403 switch(e) {
1404 #define X(NAME, VALUE, DOC) case VgsShortEnable::NAME: return #NAME;
1405 VGS_SHORT_ENABLE_LIST(X)
1406 #undef X
1407 default: return "UNKNOWN";
1408 }
1409}
1410#undef VGS_SHORT_ENABLE_LIST
1411
1412//--------------------------------------
1413// VGS Protection Blanking Time
1414//--------------------------------------
1426#define VGS_BLANKING_TIME_LIST(X) \
1427 X(OFF, 0, ) \
1428 X(T_0_25_MICROSEC, 1, ) \
1429 X(T_0_5_MICROSEC, 2, ) \
1430 X(T_1_MICROSEC, 3, )
1431
1432enum class VgsBlankingTime : uint8_t {
1433 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1434 VGS_BLANKING_TIME_LIST(X)
1435 #undef X
1436};
1437
1438inline const char* to_string(VgsBlankingTime t) {
1439 switch(t) {
1440 #define X(NAME, VALUE, DOC) case VgsBlankingTime::NAME: return #NAME;
1441 VGS_BLANKING_TIME_LIST(X)
1442 #undef X
1443 default: return "UNKNOWN";
1444 }
1445}
1446#undef VGS_BLANKING_TIME_LIST
1447
1448//--------------------------------------
1449// VGS Protection Deglitch Time
1450//--------------------------------------
1466#define VGS_DEGLITCH_TIME_LIST(X) \
1467 X(OFF, 0, ) \
1468 X(T_0_25_MICROSEC, 1, ) \
1469 X(T_0_5_MICROSEC, 2, ) \
1470 X(T_1_MICROSEC, 3, ) \
1471 X(T_2_MICROSEC, 4, ) \
1472 X(T_4_MICROSEC, 5, ) \
1473 X(T_6_MICROSEC, 6, ) \
1474 X(T_8_MICROSEC, 7, )
1475
1476enum class VgsDeglitchTime : uint8_t {
1477 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1478 VGS_DEGLITCH_TIME_LIST(X)
1479 #undef X
1480};
1481
1482inline const char* to_string(VgsDeglitchTime t) {
1483 switch(t) {
1484 #define X(NAME, VALUE, DOC) case VgsDeglitchTime::NAME: return #NAME;
1485 VGS_DEGLITCH_TIME_LIST(X)
1486 #undef X
1487 default: return "UNKNOWN";
1488 }
1489}
1490#undef VGS_DEGLITCH_TIME_LIST
1491
1493// //
1494// ███╗ ███╗ ██████╗ ████████╗ ██████╗ ██████╗ ██████╗ ██████╗ ███╗ ██╗███████╗██╗ ██████╗ //
1495// ████╗ ████║██╔═══██╗╚══██╔══╝██╔═══██╗██╔══██╗ ██╔════╝██╔═══██╗████╗ ██║██╔════╝██║██╔════╝ //
1496// ██╔████╔██║██║ ██║ ██║ ██║ ██║██████╔╝ ██║ ██║ ██║██╔██╗ ██║█████╗ ██║██║ ███╗ //
1497// ██║╚██╔╝██║██║ ██║ ██║ ██║ ██║██╔══██╗ ██║ ██║ ██║██║╚██╗██║██╔══╝ ██║██║ ██║ //
1498// ██║ ╚═╝ ██║╚██████╔╝ ██║ ╚██████╔╝██║ ██║ ╚██████╗╚██████╔╝██║ ╚████║██║ ██║╚██████╔╝ //
1499// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ //
1500// //
1501//==================================================================================================================//
1502// MOTOR CONFIG SECTION //
1503//==================================================================================================================//
1505
1507// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1508// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1509// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1511
1512//--------------------------------------
1513// Motor Configuration Parameters
1514//--------------------------------------
1529#define MOTOR_CONFIG_LIST(X) \
1530 X(MOTOR_TYPE, 0, ) \
1531 X(MOTOR_POLE_PAIRS, 1, ) \
1532 X(MOTOR_DIRECTION, 2, ) \
1533 X(MOTOR_PWM_FREQUENCY, 3, ) \
1534 X(COMMUTATION_MODE, 4, ) \
1535 X(OUTPUT_VOLTAGE_LIMIT, 5, ) \
1536 X(PWM_SWITCHING_SCHEME, 8, ) \
1537 X(IDLE_MOTOR_PWM_BEHAVIOR, 9, )
1538
1539enum class MotorConfig : uint16_t {
1540 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1541 MOTOR_CONFIG_LIST(X)
1542 #undef X
1543};
1544
1545inline const char* to_string(MotorConfig config) {
1546 switch(config) {
1547 #define X(NAME, VALUE, DOC) case MotorConfig::NAME: return #NAME;
1548 MOTOR_CONFIG_LIST(X)
1549 #undef X
1550 default: return "UNKNOWN";
1551 }
1552}
1553
1555// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1556// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1557// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1559
1560//--------------------------------------
1561// Motor Types
1562//--------------------------------------
1574#define MOTOR_TYPE_LIST(X) \
1575 X(NO_MOTOR, 0, ) \
1576 X(DC_MOTOR, 1, ) \
1577 X(STEPPER_MOTOR, 2, ) \
1578 X(BLDC_MOTOR, 3, )
1579
1580enum class MotorType : uint8_t {
1581 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1582 MOTOR_TYPE_LIST(X)
1583 #undef X
1584};
1585
1586inline const char* to_string(MotorType type) {
1587 switch(type) {
1588 #define X(NAME, VALUE, DOC) case MotorType::NAME: return #NAME;
1589 MOTOR_TYPE_LIST(X)
1590 #undef X
1591 default: return "UNKNOWN";
1592 }
1593}
1594#undef MOTOR_TYPE_LIST
1595
1596//--------------------------------------
1597// Motor Direction
1598//--------------------------------------
1608#define MOTOR_DIRECTION_LIST(X) \
1609 X(FORWARD, 0, ) \
1610 X(REVERSE, 1, )
1611
1612enum class MotorDirection : uint8_t {
1613 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1614 MOTOR_DIRECTION_LIST(X)
1615 #undef X
1616};
1617
1618inline const char* to_string(MotorDirection direction) {
1619 switch(direction) {
1620 #define X(NAME, VALUE, DOC) case MotorDirection::NAME: return #NAME;
1621 MOTOR_DIRECTION_LIST(X)
1622 #undef X
1623 default: return "UNKNOWN";
1624 }
1625}
1626#undef MOTOR_DIRECTION_LIST
1627
1628//--------------------------------------
1629// PWM Switching Schemes
1630//--------------------------------------
1641#define PWM_SWITCHING_SCHEME_LIST(X) \
1642 X(STANDARD, 0, ) \
1643 X(SVPWM, 1, ) \
1644 X(FLAT_BOTTOM, 2, )
1645
1646enum class PwmSwitchingScheme : uint8_t {
1647 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1648 PWM_SWITCHING_SCHEME_LIST(X)
1649 #undef X
1650};
1651
1652inline const char* to_string(PwmSwitchingScheme scheme) {
1653 switch(scheme) {
1654 #define X(NAME, VALUE, DOC) case PwmSwitchingScheme::NAME: return #NAME;
1655 PWM_SWITCHING_SCHEME_LIST(X)
1656 #undef X
1657 default: return "UNKNOWN";
1658 }
1659}
1660#undef PWM_SWITCHING_SCHEME_LIST
1661
1664
1734//--------------------------------------
1735// Commutation Modes
1736//--------------------------------------
1754#define COMMUTATION_MODE_LIST(X) \
1755 X(SYSTEM_OFF, 0, ) \
1756 X(SYSTEM_OFF_LOW_SIDE_FETS_ON, 1, ) \
1757 X(SYSTEM_OFF_HIGH_SIDE_FETS_ON,2, ) \
1758 X(FOC_OPENLOOP_VOLTAGE_MODE, 3, ) \
1759 X(FOC_OPENLOOP_CURRENT_MODE, 4, ) \
1760 X(FOC_ABN, 5, ) \
1761 X(FOC_HALL_SENSOR, 6, ) \
1762 X(RESERVED, 7, ) \
1763 X(FOC_SPI_ENC, 8, )
1764
1765enum class CommutationMode : std::uint8_t {
1766 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1767 COMMUTATION_MODE_LIST(X)
1768 #undef X
1769};
1770
1771inline const char* to_string(CommutationMode mode) {
1772 switch(mode) {
1773 #define X(NAME, VALUE, DOC) case CommutationMode::NAME: return #NAME;
1774 COMMUTATION_MODE_LIST(X)
1775 #undef X
1776 default: return "UNKNOWN";
1777 }
1778}
1779#undef COMMUTATION_MODE_LIST
1781
1784//--------------------------------------
1785// Idle Motor PWM Behavior
1786//--------------------------------------
1796#define IDLE_MOTOR_PWM_BEHAVIOR_LIST(X) \
1797 X(PWM_ON_WHEN_MOTOR_IDLE, 0, ) \
1798 X(PWM_OFF_WHEN_MOTOR_IDLE, 1, )
1799
1800enum class IdleMotorPwmBehavior : std::uint8_t {
1801 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1802 IDLE_MOTOR_PWM_BEHAVIOR_LIST(X)
1803 #undef X
1804};
1805
1806inline const char* to_string(IdleMotorPwmBehavior behavior) {
1807 switch(behavior) {
1808 #define X(NAME, VALUE, DOC) case IdleMotorPwmBehavior::NAME: return #NAME;
1809 IDLE_MOTOR_PWM_BEHAVIOR_LIST(X)
1810 #undef X
1811 default: return "UNKNOWN";
1812 }
1813}
1814#undef IDLE_MOTOR_PWM_BEHAVIOR_LIST
1816
1818// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
1819// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
1820// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
1822
1823//--------------------------------------
1824// ADC Configuration Parameters
1825//--------------------------------------
1863#define ADC_CONFIG_LIST(X) \
1864 X(ADC_SHUNT_TYPE, 12, ) \
1865 X(ADC_I0_RAW, 13, ) \
1866 X(ADC_I1_RAW, 14, ) \
1867 X(ADC_I2_RAW, 15, ) \
1868 X(ADC_I3_RAW, 16, ) \
1869 X(CSA_GAIN_ADC_I0_TO_ADC_I2, 17, ) \
1870 X(CSA_GAIN_ADC_I3, 18, ) \
1871 X(CSA_FILTER_ADC_I0_TO_ADC_I2,19, ) \
1872 X(CSA_FILTER_ADC_I3, 20, ) \
1873 X(CURRENT_SCALING_FACTOR, 21, ) \
1874 X(PHASE_UX1_ADC_MAPPING, 22, ) \
1875 X(PHASE_VX2_ADC_MAPPING, 23, ) \
1876 X(PHASE_WY1_ADC_MAPPING, 24, ) \
1877 X(PHASE_Y2_ADC_MAPPING, 25, ) \
1878 X(ADC_I0_SCALE, 26, ) \
1879 X(ADC_I1_SCALE, 27, ) \
1880 X(ADC_I2_SCALE, 28, ) \
1881 X(ADC_I3_SCALE, 29, ) \
1882 X(ADC_I0_INVERTED, 30, ) \
1883 X(ADC_I1_INVERTED, 31, ) \
1884 X(ADC_I2_INVERTED, 32, ) \
1885 X(ADC_I3_INVERTED, 33, ) \
1886 X(ADC_I0_OFFSET, 34, ) \
1887 X(ADC_I1_OFFSET, 35, ) \
1888 X(ADC_I2_OFFSET, 36, ) \
1889 X(ADC_I3_OFFSET, 37, ) \
1890 X(ADC_I0, 38, ) \
1891 X(ADC_I1, 39, ) \
1892 X(ADC_I2, 40, ) \
1893 X(ADC_I3, 41, )
1894
1895enum class AdcConfig : uint16_t {
1896 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1897 ADC_CONFIG_LIST(X)
1898 #undef X
1899};
1900
1901inline const char* to_string(AdcConfig config) {
1902 switch(config) {
1903 #define X(NAME, VALUE, DOC) case AdcConfig::NAME: return #NAME;
1904 ADC_CONFIG_LIST(X)
1905 #undef X
1906 default: return "UNKNOWN";
1907 }
1908}
1909
1911// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
1912// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
1913// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
1915
1916//--------------------------------------
1917// ADC Shunt Types
1918//--------------------------------------
1931#define ADC_SHUNT_TYPE_LIST(X) \
1932 X(INLINE_UVW, 0, ) \
1933 X(INLINE_VW, 1, ) \
1934 X(INLINE_UW, 2, ) \
1935 X(INLINE_UV, 3, ) \
1936 X(BOTTOM_SHUNTS, 4, )
1937
1938enum class AdcShuntType : uint8_t {
1939 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1940 ADC_SHUNT_TYPE_LIST(X)
1941 #undef X
1942};
1943
1944inline const char* to_string(AdcShuntType t) {
1945 switch(t) {
1946 #define X(NAME, VALUE, DOC) case AdcShuntType::NAME: return #NAME;
1947 ADC_SHUNT_TYPE_LIST(X)
1948 #undef X
1949 default: return "UNKNOWN";
1950 }
1951}
1952#undef ADC_SHUNT_TYPE_LIST
1953
1954//--------------------------------------
1955// Current Sense Amplifier Gain
1956//--------------------------------------
1969#define CSA_GAIN_LIST(X) \
1970 X(GAIN_5X, 0, ) \
1971 X(GAIN_10X, 1, ) \
1972 X(GAIN_20X, 2, ) \
1973 X(GAIN_40X, 3, ) \
1974 X(GAIN_1X_BYPASS_CSA, 4, )
1975
1976enum class CsaGain : uint8_t {
1977 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
1978 CSA_GAIN_LIST(X)
1979 #undef X
1980};
1981
1982inline const char* to_string(CsaGain g) {
1983 switch(g) {
1984 #define X(NAME, VALUE, DOC) case CsaGain::NAME: return #NAME;
1985 CSA_GAIN_LIST(X)
1986 #undef X
1987 default: return "UNKNOWN";
1988 }
1989}
1990#undef CSA_GAIN_LIST
1991
1992//--------------------------------------
1993// Current Sense Amplifier Filter
1994//--------------------------------------
2006#define CSA_FILTER_LIST(X) \
2007 X(T_0_55_MICROSEC, 0, ) \
2008 X(T_0_75_MICROSEC, 1, ) \
2009 X(T_1_0_MICROSEC, 2, ) \
2010 X(T_1_35_MICROSEC, 3, )
2011
2012enum class CsaFilter : uint8_t {
2013 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2014 CSA_FILTER_LIST(X)
2015 #undef X
2016};
2017
2018inline const char* to_string(CsaFilter f) {
2019 switch(f) {
2020 #define X(NAME, VALUE, DOC) case CsaFilter::NAME: return #NAME;
2021 CSA_FILTER_LIST(X)
2022 #undef X
2023 default: return "UNKNOWN";
2024 }
2025}
2026#undef CSA_FILTER_LIST
2027
2028//--------------------------------------
2029// ADC Mapping
2030//--------------------------------------
2042#define ADC_MAPPING_LIST(X) \
2043 X(ADC_I0, 0, ) \
2044 X(ADC_I1, 1, ) \
2045 X(ADC_I2, 2, ) \
2046 X(ADC_I3, 3, )
2047
2048enum class AdcMapping : uint8_t {
2049 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2050 ADC_MAPPING_LIST(X)
2051 #undef X
2052};
2053
2054inline const char* to_string(AdcMapping m) {
2055 switch(m) {
2056 #define X(NAME, VALUE, DOC) case AdcMapping::NAME: return #NAME;
2057 ADC_MAPPING_LIST(X)
2058 #undef X
2059 default: return "UNKNOWN";
2060 }
2061}
2062#undef ADC_MAPPING_LIST
2063
2064//--------------------------------------
2065// ADC Inversion Settings
2066//--------------------------------------
2076#define ADC_INVERSION_LIST(X) \
2077 X(NOT_INVERTED, 0, ) \
2078 X(INVERTED, 1, )
2079
2080enum class AdcInversion : uint8_t {
2081 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2082 ADC_INVERSION_LIST(X)
2083 #undef X
2084};
2085
2086inline const char* to_string(AdcInversion i) {
2087 switch(i) {
2088 #define X(NAME, VALUE, DOC) case AdcInversion::NAME: return #NAME;
2089 ADC_INVERSION_LIST(X)
2090 #undef X
2091 default: return "UNKNOWN";
2092 }
2093}
2094#undef ADC_INVERSION_LIST
2095
2096//--------------------------------------
2097// PWM Frequency Configuration
2098//--------------------------------------
2111#define PWM_FREQUENCY_LIST(X) \
2112 X(STANDARD_BLDC, 25000, ) \
2113 X(STANDARD_STEPPER, 20000, ) \
2114 X(FAST_BLDC, 50000, ) \
2115 X(ULTRA_FAST_BLDC, 100000, ) \
2116 X(MINIMUM_SILENT, 20001, )
2117
2118enum class PwmFrequency : uint32_t {
2119 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2120 PWM_FREQUENCY_LIST(X)
2121 #undef X
2122};
2123
2124inline const char* to_string(PwmFrequency f) {
2125 switch(f) {
2126 #define X(NAME, VALUE, DOC) case PwmFrequency::NAME: return #NAME;
2127 PWM_FREQUENCY_LIST(X)
2128 #undef X
2129 default: return "UNKNOWN";
2130 }
2131}
2132#undef PWM_FREQUENCY_LIST
2133
2135// //
2136// ███████╗███████╗███████╗██████╗ ██████╗ █████╗ ██████╗██╗ ██╗ //
2137// ██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝██║ ██╔╝ //
2138// █████╗ █████╗ █████╗ ██║ ██║██████╔╝███████║██║ █████╔╝ //
2139// ██╔══╝ ██╔══╝ ██╔══╝ ██║ ██║██╔══██╗██╔══██║██║ ██╔═██╗ //
2140// ██║ ███████╗███████╗██████╔╝██████╔╝██║ ██║╚██████╗██║ ██╗ //
2141// ╚═╝ ╚══════╝╚══════╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝╚═╝ ╚═╝ //
2142// //
2143// ███████╗███████╗███╗ ██╗███████╗ ██████╗ ██████╗ ███████╗ //
2144// ██╔════╝██╔════╝████╗ ██║██╔════╝██╔═══██╗██╔══██╗██╔════╝ //
2145// ███████╗█████╗ ██╔██╗ ██║███████╗██║ ██║██████╔╝███████╗ //
2146// ╚════██║██╔══╝ ██║╚██╗██║╚════██║██║ ██║██╔══██╗╚════██║ //
2147// ███████║███████╗██║ ╚████║███████║╚██████╔╝██║ ██║███████║ //
2148// ╚══════╝╚══════╝╚═╝ ╚═══╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ //
2149// //
2150//==================================================================================================================//
2151// FEEDBACK SENSOR SECTION //
2152//==================================================================================================================//
2154
2156// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2157// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2158// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2160
2161//--------------------------------------
2162// Feedback Sensor Configuration Parameters
2163//--------------------------------------
2220#define FEEDBACK_SENSOR_CONFIG_LIST(X) \
2221 X(ABN_1_PHI_E, 89, ) \
2222 X(ABN_1_STEPS, 90, ) \
2223 X(ABN_1_DIRECTION, 91, ) \
2224 X(ABN_1_INIT_METHOD, 92, ) \
2225 X(ABN_1_INIT_STATE, 93, ) \
2226 X(ABN_1_INIT_DELAY, 94, ) \
2227 X(ABN_1_INIT_VELOCITY, 95, ) \
2228 X(ABN_1_N_CHANNEL_PHI_E_OFFSET, 96, ) \
2229 X(ABN_1_N_CHANNEL_INVERTED, 97, ) \
2230 X(ABN_1_N_CHANNEL_FILTERING, 98, ) \
2231 X(ABN_1_CLEAR_ON_NEXT_NULL, 99, ) \
2232 X(ABN_1_VALUE, 100, ) \
2233 X(HALL_PHI_E, 74, ) \
2234 X(HALL_SECTOR_OFFSET, 75, ) \
2235 X(HALL_FILTER_LENGTH, 76, ) \
2236 X(HALL_POSITION_0_OFFSET, 77, ) \
2237 X(HALL_POSITION_60_OFFSET, 78, ) \
2238 X(HALL_POSITION_120_OFFSET, 79, ) \
2239 X(HALL_POSITION_180_OFFSET, 80, ) \
2240 X(HALL_POSITION_240_OFFSET, 81, ) \
2241 X(HALL_POSITION_300_OFFSET, 82, ) \
2242 X(HALL_INVERT_DIRECTION, 83, ) \
2243 X(HALL_EXTRAPOLATION_ENABLE, 84, ) \
2244 X(HALL_PHI_E_OFFSET, 85, ) \
2245 X(SPI_ENCODER_CS_SETTLE_DELAY_TIME, 181, ) \
2246 X(SPI_ENCODER_CS_IDLE_DELAY_TIME, 182, ) \
2247 X(SPI_ENCODER_MAIN_TRANSFER_CMD_SIZE, 183, ) \
2248 X(SPI_ENCODER_SECONDARY_TRANSFER_CMD_SIZE, 184, ) \
2249 X(SPI_ENCODER_TRANSFER_DATA_3_0, 185, ) \
2250 X(SPI_ENCODER_TRANSFER_DATA_7_4, 186, ) \
2251 X(SPI_ENCODER_TRANSFER_DATA_11_8, 187, ) \
2252 X(SPI_ENCODER_TRANSFER_DATA_15_12, 188, ) \
2253 X(SPI_ENCODER_TRANSFER, 189, ) \
2254 X(SPI_ENCODER_POSITION_COUNTER_MASK, 190, ) \
2255 X(SPI_ENCODER_POSITION_COUNTER_SHIFT, 191, ) \
2256 X(SPI_ENCODER_POSITION_COUNTER_VALUE, 192, ) \
2257 X(SPI_ENCODER_COMMUTATION_ANGLE, 193, ) \
2258 X(SPI_ENCODER_INITIALIZATION_METHOD, 194, ) \
2259 X(SPI_ENCODER_DIRECTION, 195, ) \
2260 X(SPI_ENCODER_OFFSET, 196, ) \
2261 X(SPI_LUT_CORRECTION_ENABLE, 197, ) \
2262 X(SPI_LUT_ADDRESS_SELECT, 198, ) \
2263 X(SPI_LUT_DATA, 199, ) \
2264 X(SPI_LUT_COMMON_SHIFT_FACTOR, 201, ) \
2265 X(ABN_2_STEPS, 174, ) \
2266 X(ABN_2_DIRECTION, 175, ) \
2267 X(ABN_2_GEAR_RATIO, 176, ) \
2268 X(ABN_2_ENABLE, 177, ) \
2269 X(ABN_2_VALUE, 178, )
2270
2271enum class FeedbackSensorConfig : uint16_t {
2272 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2273 FEEDBACK_SENSOR_CONFIG_LIST(X)
2274 #undef X
2275};
2276
2277inline const char* to_string(FeedbackSensorConfig config) {
2278 switch(config) {
2279 #define X(NAME, VALUE, DOC) case FeedbackSensorConfig::NAME: return #NAME;
2280 FEEDBACK_SENSOR_CONFIG_LIST(X)
2281 #undef X
2282 default: return "UNKNOWN";
2283 }
2284}
2285
2287// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2288// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2289// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2291
2292//--------------------------------------
2293// ABN Initialization Methods
2294//--------------------------------------
2306#define ABN_INIT_METHOD_LIST(X) \
2307 X(FORCED_PHI_E_ZERO_WITH_ACTIVE_SWING, 0, ) \
2308 X(FORCED_PHI_E_90_ZERO, 1, ) \
2309 X(USE_HALL, 2, ) \
2310 X(USE_N_CHANNEL_OFFSET, 3, )
2311
2312enum class AbnInitMethod : uint8_t {
2313 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2314 ABN_INIT_METHOD_LIST(X)
2315 #undef X
2316};
2317
2318inline const char* to_string(AbnInitMethod method) {
2319 switch(method) {
2320 #define X(NAME, VALUE, DOC) case AbnInitMethod::NAME: return #NAME;
2321 ABN_INIT_METHOD_LIST(X)
2322 #undef X
2323 default: return "UNKNOWN";
2324 }
2325}
2326#undef ABN_INIT_METHOD_LIST
2327
2328//--------------------------------------
2329// ABN Initialization States
2330//--------------------------------------
2342#define ABN_INIT_STATE_LIST(X) \
2343 X(IDLE, 0, ) \
2344 X(BUSY, 1, ) \
2345 X(WAIT, 2, ) \
2346 X(DONE, 3, )
2347
2348enum class AbnInitState : uint8_t {
2349 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2350 ABN_INIT_STATE_LIST(X)
2351 #undef X
2352};
2353
2354inline const char* to_string(AbnInitState state) {
2355 switch(state) {
2356 #define X(NAME, VALUE, DOC) case AbnInitState::NAME: return #NAME;
2357 ABN_INIT_STATE_LIST(X)
2358 #undef X
2359 default: return "UNKNOWN";
2360 }
2361}
2362#undef ABN_INIT_STATE_LIST
2363
2364//--------------------------------------
2365// ABN N-Channel Filtering Modes
2366//--------------------------------------
2379#define ABN_N_CHANNEL_FILTERING_LIST(X) \
2380 X(FILTERING_OFF, 0, ) \
2381 X(N_EVENT_ON_A_HIGH_B_HIGH, 1, ) \
2382 X(N_EVENT_ON_A_HIGH_B_LOW, 2, ) \
2383 X(N_EVENT_ON_A_LOW_B_HIGH, 3, ) \
2384 X(N_EVENT_ON_A_LOW_B_LOW, 4, )
2385
2386enum class AbnNChannelFiltering : uint8_t {
2387 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2388 ABN_N_CHANNEL_FILTERING_LIST(X)
2389 #undef X
2390};
2391
2392inline const char* to_string(AbnNChannelFiltering filtering) {
2393 switch(filtering) {
2394 #define X(NAME, VALUE, DOC) case AbnNChannelFiltering::NAME: return #NAME;
2395 ABN_N_CHANNEL_FILTERING_LIST(X)
2396 #undef X
2397 default: return "UNKNOWN";
2398 }
2399}
2400#undef ABN_N_CHANNEL_FILTERING_LIST
2401
2402//--------------------------------------
2403// Hall Sector Offsets
2404//--------------------------------------
2418#define HALL_SECTOR_OFFSET_LIST(X) \
2419 X(DEG_0, 0, ) \
2420 X(DEG_60, 1, ) \
2421 X(DEG_120, 2, ) \
2422 X(DEG_180, 3, ) \
2423 X(DEG_240, 4, ) \
2424 X(DEG_300, 5, )
2425
2426enum class HallSectorOffset : uint8_t {
2427 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2428 HALL_SECTOR_OFFSET_LIST(X)
2429 #undef X
2430};
2431
2432inline const char* to_string(HallSectorOffset offset) {
2433 switch(offset) {
2434 #define X(NAME, VALUE, DOC) case HallSectorOffset::NAME: return #NAME;
2435 HALL_SECTOR_OFFSET_LIST(X)
2436 #undef X
2437 default: return "UNKNOWN";
2438 }
2439}
2440#undef HALL_SECTOR_OFFSET_LIST
2441
2442//--------------------------------------
2443// SPI Encoder Transfer Modes
2444//--------------------------------------
2455#define SPI_ENCODER_TRANSFER_LIST(X) \
2456 X(OFF, 0, ) \
2457 X(TRIGGER_SINGLE_TRANSFER, 1, ) \
2458 X(CONTINUOUS_POSITION_COUNTER_READ, 2, )
2459
2460enum class SpiEncoderTransfer : uint8_t {
2461 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2462 SPI_ENCODER_TRANSFER_LIST(X)
2463 #undef X
2464};
2465
2466inline const char* to_string(SpiEncoderTransfer transfer) {
2467 switch(transfer) {
2468 #define X(NAME, VALUE, DOC) case SpiEncoderTransfer::NAME: return #NAME;
2469 SPI_ENCODER_TRANSFER_LIST(X)
2470 #undef X
2471 default: return "UNKNOWN";
2472 }
2473}
2474#undef SPI_ENCODER_TRANSFER_LIST
2475
2476//--------------------------------------
2477// SPI Encoder Initialization Methods
2478//--------------------------------------
2489#define SPI_INIT_METHOD_LIST(X) \
2490 X(FORCED_PHI_E_ZERO_WITH_ACTIVE_SWING, 0, ) \
2491 X(FORCED_PHI_E_90_ZERO, 1, ) \
2492 X(USE_OFFSET, 2, )
2493
2494enum class SpiInitMethod : uint8_t {
2495 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2496 SPI_INIT_METHOD_LIST(X)
2497 #undef X
2498};
2499
2500inline const char* to_string(SpiInitMethod method) {
2501 switch(method) {
2502 #define X(NAME, VALUE, DOC) case SpiInitMethod::NAME: return #NAME;
2503 SPI_INIT_METHOD_LIST(X)
2504 #undef X
2505 default: return "UNKNOWN";
2506 }
2507}
2508#undef SPI_INIT_METHOD_LIST
2509
2510//--------------------------------------
2511// Enable/Disable Settings
2512//--------------------------------------
2522#define ENABLE_DISABLE_LIST(X) \
2523 X(DISABLED, 0, ) \
2524 X(ENABLED, 1, )
2525
2526enum class EnableDisable : uint8_t {
2527 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2528 ENABLE_DISABLE_LIST(X)
2529 #undef X
2530};
2531
2532inline const char* to_string(EnableDisable setting) {
2533 switch(setting) {
2534 #define X(NAME, VALUE, DOC) case EnableDisable::NAME: return #NAME;
2535 ENABLE_DISABLE_LIST(X)
2536 #undef X
2537 default: return "UNKNOWN";
2538 }
2539}
2540#undef ENABLE_DISABLE_LIST
2541
2542//--------------------------------------
2543// Direction Settings
2544//--------------------------------------
2554#define DIRECTION_LIST(X) \
2555 X(NOT_INVERTED, 0, ) \
2556 X(INVERTED, 1, )
2557
2558enum class Direction : uint8_t {
2559 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2560 DIRECTION_LIST(X)
2561 #undef X
2562};
2563
2564inline const char* to_string(Direction direction) {
2565 switch(direction) {
2566 #define X(NAME, VALUE, DOC) case Direction::NAME: return #NAME;
2567 DIRECTION_LIST(X)
2568 #undef X
2569 default: return "UNKNOWN";
2570 }
2571}
2572#undef DIRECTION_LIST
2573
2575// //
2576// ████████╗ ██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗ █████╗ ███╗ ██╗██████╗ //
2577// ╚══██╔══╝██╔═══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝ ██╔══██╗████╗ ██║██╔══██╗ //
2578// ██║ ██║ ██║██████╔╝██║ ██║██║ ██║█████╗ ███████║██╔██╗ ██║██║ ██║ //
2579// ██║ ██║ ██║██╔══██╗██║▄▄ ██║██║ ██║██╔══╝ ██╔══██║██║╚██╗██║██║ ██║ //
2580// ██║ ╚██████╔╝██║ ██║╚██████╔╝╚██████╔╝███████╗ ██║ ██║██║ ╚████║██████╔╝ //
2581// ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚══▀▀═╝ ╚═════╝ ╚══════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ //
2582// //
2583// ███████╗██╗ ██╗ ██╗██╗ ██╗ ██████╗ ██████╗ ███╗ ██╗████████╗██████╗ ██████╗ ██╗ //
2584// ██╔════╝██║ ██║ ██║╚██╗██╔╝ ██╔════╝██╔═══██╗████╗ ██║╚══██╔══╝██╔══██╗██╔═══██╗██║ //
2585// █████╗ ██║ ██║ ██║ ╚███╔╝ ██║ ██║ ██║██╔██╗ ██║ ██║ ██████╔╝██║ ██║██║ //
2586// ██╔══╝ ██║ ██║ ██║ ██╔██╗ ██║ ██║ ██║██║╚██╗██║ ██║ ██╔══██╗██║ ██║██║ //
2587// ██║ ███████╗╚██████╔╝██╔╝ ██╗ ╚██████╗╚██████╔╝██║ ╚████║ ██║ ██║ ██║╚██████╔╝███████╗ //
2588// ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝ //
2589// //
2590//==================================================================================================================//
2591// TORQUE AND FLUX CONTROL SECTION //
2592//==================================================================================================================//
2593//==================================================================================================================//
2594
2596// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2597// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2598// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2600
2603//--------------------------------------
2604// Torque and Flux Control Parameters
2605//--------------------------------------
2634#define TORQUE_FLUX_CONTROL_LIST(X) \
2635 X(MAX_TORQUE, 6, ) \
2636 X(MAX_FLUX, 7, ) \
2637 X(TARGET_TORQUE, 104, ) \
2638 X(ACTUAL_TORQUE, 105, ) \
2639 X(TARGET_FLUX, 106, ) \
2640 X(ACTUAL_FLUX, 107, ) \
2641 X(TORQUE_OFFSET, 108, ) \
2642 X(TORQUE_P, 109, ) \
2643 X(TORQUE_I, 110, ) \
2644 X(FLUX_P, 111, ) \
2645 X(FLUX_I, 112, ) \
2646 X(SEPARATE_TORQUE_FLUX_PI_PARAMETERS,113, ) \
2647 X(CURRENT_NORM_P, 114, ) \
2648 X(CURRENT_NORM_I, 115, ) \
2649 X(TORQUE_PI_ERROR, 116, ) \
2650 X(FLUX_PI_ERROR, 117, ) \
2651 X(TORQUE_PI_INTEGRATOR, 118, ) \
2652 X(FLUX_PI_INTEGRATOR, 119, ) \
2653 X(FLUX_OFFSET, 120, ) \
2654 X(FIELDWEAKENING_I, 308, ) \
2655 X(FIELDWEAKENING_VOLTAGE_THRESHOLD, 310, )
2656
2657enum class TorqueFluxControl : uint16_t {
2658 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2659 TORQUE_FLUX_CONTROL_LIST(X)
2660 #undef X
2661};
2662
2663inline const char* to_string(TorqueFluxControl config) {
2664 switch(config) {
2665 #define X(NAME, VALUE, DOC) case TorqueFluxControl::NAME: return #NAME;
2666 TORQUE_FLUX_CONTROL_LIST(X)
2667 #undef X
2668 default: return "UNKNOWN";
2669 }
2670}
2672
2674// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2675// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2676// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2678
2681//--------------------------------------
2682// Torque/Flux PI Separation
2683//--------------------------------------
2693#define TORQUE_FLUX_PI_SEPARATION_LIST(X) \
2694 X(TORQUE_FLUX_PI_COMBINED, 0, ) \
2695 X(TORQUE_FLUX_PI_SEPARATED, 1, )
2696
2697enum class TorqueFluxPiSeparation : uint8_t {
2698 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2699 TORQUE_FLUX_PI_SEPARATION_LIST(X)
2700 #undef X
2701};
2702
2703inline const char* to_string(TorqueFluxPiSeparation separation) {
2704 switch(separation) {
2705 #define X(NAME, VALUE, DOC) case TorqueFluxPiSeparation::NAME: return #NAME;
2706 TORQUE_FLUX_PI_SEPARATION_LIST(X)
2707 #undef X
2708 default: return "UNKNOWN";
2709 }
2710}
2711#undef TORQUE_FLUX_PI_SEPARATION_LIST
2713
2716//--------------------------------------
2717// Current PI Normalization Format
2718//--------------------------------------
2728#define CURRENT_PI_NORMALIZATION_LIST(X) \
2729 X(SHIFT_8_BIT, 0, ) \
2730 X(SHIFT_16_BIT, 1, )
2731
2732enum class CurrentPiNormalization : uint8_t {
2733 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2734 CURRENT_PI_NORMALIZATION_LIST(X)
2735 #undef X
2736};
2737
2738inline const char* to_string(CurrentPiNormalization norm) {
2739 switch(norm) {
2740 #define X(NAME, VALUE, DOC) case CurrentPiNormalization::NAME: return #NAME;
2741 CURRENT_PI_NORMALIZATION_LIST(X)
2742 #undef X
2743 default: return "UNKNOWN";
2744 }
2745}
2746#undef CURRENT_PI_NORMALIZATION_LIST
2748
2750// //
2751// ██╗ ██╗███████╗██╗ ██████╗ ██████╗██╗████████╗██╗ ██╗ ███╗ ███╗ ██████╗ ██████╗ ███████╗ //
2752// ██║ ██║██╔════╝██║ ██╔═══██╗██╔════╝██║╚══██╔══╝╚██╗ ██╔╝ ████╗ ████║██╔═══██╗██╔══██╗██╔════╝ //
2753// ██║ ██║█████╗ ██║ ██║ ██║██║ ██║ ██║ ╚████╔╝ ██╔████╔██║██║ ██║██║ ██║█████╗ //
2754// ╚██╗ ██╔╝██╔══╝ ██║ ██║ ██║██║ ██║ ██║ ╚██╔╝ ██║╚██╔╝██║██║ ██║██║ ██║██╔══╝ //
2755// ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╗██║ ██║ ██║ ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗ //
2756// ╚═══╝ ╚══════╝╚══════╝ ╚═════╝ ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ //
2757// //
2758//==================================================================================================================//
2759// VELOCITY MODE SECTION //
2760//==================================================================================================================//
2762
2764// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
2765// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
2766// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
2768
2771//--------------------------------------
2772// Velocity Control Parameters
2773//--------------------------------------
2820#define VELOCITY_CONTROL_LIST(X) \
2821 X(VELOCITY_SENSOR_SELECTION, 123, ) \
2822 X(TARGET_VELOCITY, 124, ) \
2823 X(ACTUAL_VELOCITY, 125, ) \
2824 X(VELOCITY_OFFSET, 126, ) \
2825 X(VELOCITY_P, 127, ) \
2826 X(VELOCITY_I, 128, ) \
2827 X(VELOCITY_NORM_P, 129, ) \
2828 X(VELOCITY_NORM_I, 130, ) \
2829 X(VELOCITY_PI_INTEGRATOR, 131, ) \
2830 X(VELOCITY_PI_ERROR, 132, ) \
2831 X(VELOCITY_SCALING_FACTOR, 133, ) \
2832 X(VELOCITY_LOOP_DOWNSAMPLING, 135, ) \
2833 X(VELOCITY_METER_SWITCH_THRESHOLD, 137, ) \
2834 X(VELOCITY_METER_SWITCH_HYSTERESIS, 138, ) \
2835 X(VELOCITY_METER_MODE, 139, ) \
2836 X(OPENLOOP_ANGLE, 45, ) \
2837 X(OPENLOOP_CURRENT, 46, ) \
2838 X(OPENLOOP_VOLTAGE, 47, ) \
2839 X(ACCELERATION_FF_GAIN, 50, ) \
2840 X(ACCELERATION_FF_SHIFT, 51, ) \
2841 X(RAMP_ENABLE, 52, ) \
2842 X(DIRECT_VELOCITY_MODE, 53, ) \
2843 X(RAMP_AMAX, 54, ) \
2844 X(RAMP_A1, 55, ) \
2845 X(RAMP_A2, 56, ) \
2846 X(RAMP_DMAX, 57, ) \
2847 X(RAMP_D1, 58, ) \
2848 X(RAMP_D2, 59, ) \
2849 X(RAMP_VMAX, 60, ) \
2850 X(RAMP_V1, 61, ) \
2851 X(RAMP_V2, 62, ) \
2852 X(RAMP_VSTART, 63, ) \
2853 X(RAMP_VSTOP, 64, ) \
2854 X(RAMP_TVMAX, 65, ) \
2855 X(RAMP_TZEROWAIT, 66, ) \
2856 X(ACCELERATION_FEEDFORWARD_ENABLE, 67, ) \
2857 X(VELOCITY_FEEDFORWARD_ENABLE, 68, ) \
2858 X(RAMP_VELOCITY, 69, ) \
2859 X(RAMP_POSITION, 70, ) \
2860
2861enum class VelocityControl : uint16_t {
2862 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2863 VELOCITY_CONTROL_LIST(X)
2864 #undef X
2865};
2866
2867inline const char* to_string(VelocityControl config) {
2868 switch(config) {
2869 #define X(NAME, VALUE, DOC) case VelocityControl::NAME: return #NAME;
2870 VELOCITY_CONTROL_LIST(X)
2871 #undef X
2872 default: return "UNKNOWN";
2873 }
2874}
2876
2878// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
2879// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
2880// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
2882
2885//--------------------------------------
2886// Velocity Sensor Selection
2887//--------------------------------------
2900#define VELOCITY_SENSOR_SELECTION_LIST(X) \
2901 X(SAME_AS_COMMUTATION, 0, ) \
2902 X(DIGITAL_HALL, 1, ) \
2903 X(ABN1_ENCODER, 2, ) \
2904 X(ABN2_ENCODER, 3, ) \
2905 X(SPI_ENCODER, 4, )
2906
2907enum class VelocitySensorSelection : uint8_t {
2908 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2909 VELOCITY_SENSOR_SELECTION_LIST(X)
2910 #undef X
2911};
2912
2913inline const char* to_string(VelocitySensorSelection selection) {
2914 switch(selection) {
2915 #define X(NAME, VALUE, DOC) case VelocitySensorSelection::NAME: return #NAME;
2916 VELOCITY_SENSOR_SELECTION_LIST(X)
2917 #undef X
2918 default: return "UNKNOWN";
2919 }
2920}
2921#undef VELOCITY_SENSOR_SELECTION_LIST
2923
2926//--------------------------------------
2927// Velocity PI Normalization
2928//--------------------------------------
2940#define VELOCITY_PI_NORM_LIST(X) \
2941 X(NO_SHIFT, 0, ) \
2942 X(SHIFT_8_BIT, 1, ) \
2943 X(SHIFT_16_BIT,2, ) \
2944 X(SHIFT_24_BIT,3, )
2945
2946enum class VelocityPiNorm : uint8_t {
2947 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2948 VELOCITY_PI_NORM_LIST(X)
2949 #undef X
2950};
2951
2952inline const char* to_string(VelocityPiNorm norm) {
2953 switch(norm) {
2954 #define X(NAME, VALUE, DOC) case VelocityPiNorm::NAME: return #NAME;
2955 VELOCITY_PI_NORM_LIST(X)
2956 #undef X
2957 default: return "UNKNOWN";
2958 }
2959}
2960#undef VELOCITY_PI_NORM_LIST
2962
2965//--------------------------------------
2966// Velocity Meter Modes
2967//--------------------------------------
2978#define VELOCITY_METER_MODE_LIST(X) \
2979 X(PERIOD_METER, 0, ) \
2980 X(FREQUENCY_METER, 1, ) \
2981 X(SOFTWARE_METER, 2, )
2982
2983enum class VelocityMeterMode : std::uint8_t {
2984 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
2985 VELOCITY_METER_MODE_LIST(X)
2986 #undef X
2987};
2988
2989inline const char* to_string(VelocityMeterMode mode) {
2990 switch(mode) {
2991 #define X(NAME, VALUE, DOC) case VelocityMeterMode::NAME: return #NAME;
2992 VELOCITY_METER_MODE_LIST(X)
2993 #undef X
2994 default: return "UNKNOWN";
2995 }
2996}
2997#undef VELOCITY_METER_MODE_LIST
2999
3002//--------------------------------------
3003// Acceleration Feedforward Shift
3004//--------------------------------------
3019#define ACCELERATION_FF_SHIFT_LIST(X) \
3020 X(NO_SHIFT, 0, ) \
3021 X(SHIFT_4_BIT, 1, ) \
3022 X(SHIFT_8_BIT, 2, ) \
3023 X(SHIFT_12_BIT, 3, ) \
3024 X(SHIFT_16_BIT, 4, ) \
3025 X(SHIFT_20_BIT, 5, ) \
3026 X(SHIFT_24_BIT, 6, )
3027
3028enum class AccelerationFFShift : uint8_t {
3029 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3030 ACCELERATION_FF_SHIFT_LIST(X)
3031 #undef X
3032};
3033
3034inline const char* to_string(AccelerationFFShift shift) {
3035 switch(shift) {
3036 #define X(NAME, VALUE, DOC) case AccelerationFFShift::NAME: return #NAME;
3037 ACCELERATION_FF_SHIFT_LIST(X)
3038 #undef X
3039 default: return "UNKNOWN";
3040 }
3041}
3042#undef ACCELERATION_FF_SHIFT_LIST
3044
3046// //
3047// ██████╗ ██████╗ ███████╗██╗████████╗██╗ ██████╗ ███╗ ██╗ ███╗ ███╗ ██████╗ ██████╗ ███████╗ //
3048// ██╔══██╗██╔═══██╗██╔════╝██║╚══██╔══╝██║██╔═══██╗████╗ ██║ ████╗ ████║██╔═══██╗██╔══██╗██╔════╝ //
3049// ██████╔╝██║ ██║███████╗██║ ██║ ██║██║ ██║██╔██╗ ██║ ██╔████╔██║██║ ██║██║ ██║█████╗ //
3050// ██╔═══╝ ██║ ██║╚════██║██║ ██║ ██║██║ ██║██║╚██╗██║ ██║╚██╔╝██║██║ ██║██║ ██║██╔══╝ //
3051// ██║ ╚██████╔╝███████║██║ ██║ ██║╚██████╔╝██║ ╚████║ ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗ //
3052// ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ //
3053// //
3054//==================================================================================================================//
3055// POSITION MODE SECTION //
3056//==================================================================================================================//
3058
3060// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3061// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3062// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3064
3067//--------------------------------------
3068// Position Control Parameters
3069//--------------------------------------
3092#define POSITION_CONTROL_LIST(X) \
3093 X(POSITION_SENSOR_SELECTION, 142, ) \
3094 X(TARGET_POSITION, 143, ) \
3095 X(ACTUAL_POSITION, 144, ) \
3096 X(POSITION_SCALING_FACTOR, 145, ) \
3097 X(POSITION_P, 146, ) \
3098 X(POSITION_I, 147, ) \
3099 X(POSITION_NORM_P, 148, ) \
3100 X(POSITION_NORM_I, 149, ) \
3101 X(POSITION_PI_INTEGRATOR, 150, ) \
3102 X(POSITION_PI_ERROR, 151, ) \
3103 X(POSITION_LOOP_DOWNSAMPLING,153, ) \
3104 X(LATCH_POSITION, 154, ) \
3105 X(POSITION_LIMIT_LOW, 155, ) \
3106 X(POSITION_LIMIT_HIGH, 156, ) \
3107 X(POSITION_REACHED_THRESHOLD,157, )
3108
3109enum class PositionControl : uint16_t {
3110 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3111 POSITION_CONTROL_LIST(X)
3112 #undef X
3113};
3114
3115inline const char* to_string(PositionControl config) {
3116 switch(config) {
3117 #define X(NAME, VALUE, DOC) case PositionControl::NAME: return #NAME;
3118 POSITION_CONTROL_LIST(X)
3119 #undef X
3120 default: return "UNKNOWN";
3121 }
3122}
3124
3126// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3127// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3128// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3130
3133//--------------------------------------
3134// Position Sensor Selection
3135//--------------------------------------
3148#define POSITION_SENSOR_SELECTION_LIST(X) \
3149 X(SAME_AS_COMMUTATION, 0, ) \
3150 X(DIGITAL_HALL, 1, ) \
3151 X(ABN1_ENCODER, 2, ) \
3152 X(ABN2_ENCODER, 3, ) \
3153 X(SPI_ENCODER, 4, )
3154
3155enum class PositionSensorSelection : uint8_t {
3156 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3157 POSITION_SENSOR_SELECTION_LIST(X)
3158 #undef X
3159};
3160
3161inline const char* to_string(PositionSensorSelection selection) {
3162 switch(selection) {
3163 #define X(NAME, VALUE, DOC) case PositionSensorSelection::NAME: return #NAME;
3164 POSITION_SENSOR_SELECTION_LIST(X)
3165 #undef X
3166 default: return "UNKNOWN";
3167 }
3168}
3169#undef POSITION_SENSOR_SELECTION_LIST
3171
3174//--------------------------------------
3175// Position PI Normalization
3176//--------------------------------------
3188#define POSITION_PI_NORM_LIST(X) \
3189 X(NO_SHIFT, 0, ) \
3190 X(SHIFT_8_BIT, 1, ) \
3191 X(SHIFT_16_BIT, 2, ) \
3192 X(SHIFT_24_BIT, 3, )
3193
3194enum class PositionPiNorm : uint8_t {
3195 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3196 POSITION_PI_NORM_LIST(X)
3197 #undef X
3198};
3199
3200inline const char* to_string(PositionPiNorm norm) {
3201 switch(norm) {
3202 #define X(NAME, VALUE, DOC) case PositionPiNorm::NAME: return #NAME;
3203 POSITION_PI_NORM_LIST(X)
3204 #undef X
3205 default: return "UNKNOWN";
3206 }
3207}
3208#undef POSITION_PI_NORM_LIST
3210
3212// //
3213// ██████╗ █████╗ ███╗ ███╗██████╗ ███████╗██████╗ ███████╗████████╗ ██████╗ ██████╗ //
3214// ██╔══██╗██╔══██╗████╗ ████║██╔══██╗██╔════╝██╔══██╗ ██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗ //
3215// ██████╔╝███████║██╔████╔██║██████╔╝█████╗ ██████╔╝ ███████╗ ██║ ██║ ██║██████╔╝ //
3216// ██╔══██╗██╔══██║██║╚██╔╝██║██╔═══╝ ██╔══╝ ██╔══██╗ ╚════██║ ██║ ██║ ██║██╔═══╝ //
3217// ██║ ██║██║ ██║██║ ╚═╝ ██║██║ ███████╗██║ ██║ ███████║ ██║ ╚██████╔╝██║ //
3218// ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═╝ ╚══════╝ ╚═╝ ╚═════╝ ╚═╝ //
3219// //
3220// ██████╗ ██████╗ ███╗ ██╗██████╗ ██╗████████╗██╗ ██████╗ ███╗ ██╗███████╗ ██╗ //
3221// ██╔════╝██╔═══██╗████╗ ██║██╔══██╗██║╚══██╔══╝██║██╔═══██╗████╗ ██║██╔════╝ ██╔╝ //
3222// ██║ ██║ ██║██╔██╗ ██║██║ ██║██║ ██║ ██║██║ ██║██╔██╗ ██║███████╗ ██╔╝ //
3223// ██║ ██║ ██║██║╚██╗██║██║ ██║██║ ██║ ██║██║ ██║██║╚██╗██║╚════██║ ██╔╝ //
3224// ╚██████╗╚██████╔╝██║ ╚████║██████╔╝██║ ██║ ██║╚██████╔╝██║ ╚████║███████║ ██╔╝ //
3225// ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ ╚═╝ //
3226// //
3227// ██████╗ ███████╗███████╗███████╗██████╗ ███████╗███╗ ██╗ ██████╗███████╗ //
3228// ██╔══██╗██╔════╝██╔════╝██╔════╝██╔══██╗██╔════╝████╗ ██║██╔════╝██╔════╝ //
3229// ██████╔╝█████╗ █████╗ █████╗ ██████╔╝█████╗ ██╔██╗ ██║██║ █████╗ //
3230// ██╔══██╗██╔══╝ ██╔══╝ ██╔══╝ ██╔══██╗██╔══╝ ██║╚██╗██║██║ ██╔══╝ //
3231// ██║ ██║███████╗██║ ███████╗██║ ██║███████╗██║ ╚████║╚██████╗███████╗ //
3232// ╚═╝ ╚═╝╚══════╝╚═╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝ ╚═════╝╚══════╝ //
3233// //
3234// ███████╗██╗ ██╗██╗████████╗ ██████╗██╗ ██╗███████╗███████╗ //
3235// ██╔════╝██║ ██║██║╚══██╔══╝██╔════╝██║ ██║██╔════╝██╔════╝ //
3236// ███████╗██║ █╗ ██║██║ ██║ ██║ ███████║█████╗ ███████╗ //
3237// ╚════██║██║███╗██║██║ ██║ ██║ ██╔══██║██╔══╝ ╚════██║ //
3238// ███████║╚███╔███╔╝██║ ██║ ╚██████╗██║ ██║███████╗███████║ //
3239// ╚══════╝ ╚══╝╚══╝ ╚═╝ ╚═╝ ╚═════╝╚═╝ ╚═╝╚══════╝╚══════╝ //
3240// //
3241//==================================================================================================================//
3242// RAMPER STOP CONDITIONS AND REFERENCE SWITCHES //
3243//==================================================================================================================//
3245
3247// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3248// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3249// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3251
3254//--------------------------------------
3255// Ramper Stop Conditions and Reference Switches
3256//--------------------------------------
3271#define RAMPER_STOP_CONFIG_LIST(X) \
3272 X(STOP_ON_VELOCITY_DEVIATION, 134, ) \
3273 X(STOP_ON_POSITION_DEVIATION, 152, ) \
3274 /* LATCH_POSITION handled in POSITION_CONTROL_LIST */ \
3275 X(REFERENCE_SWITCH_ENABLE, 161, ) \
3276 X(REFERENCE_SWITCH_POLARITY_AND_SWAP,162, ) \
3277 X(REFERENCE_SWITCH_LATCH_SETTINGS, 163, ) \
3278 X(EVENT_STOP_SETTINGS, 164, )
3279
3280enum class RamperStopConfig : uint16_t {
3281 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3282 RAMPER_STOP_CONFIG_LIST(X)
3283 #undef X
3284};
3285
3286inline const char* to_string(RamperStopConfig config) {
3287 switch(config) {
3288 #define X(NAME, VALUE, DOC) case RamperStopConfig::NAME: return #NAME;
3289 RAMPER_STOP_CONFIG_LIST(X)
3290 #undef X
3291 default: return "UNKNOWN";
3292 }
3293}
3295
3297// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3298// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3299// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3301
3304//--------------------------------------
3305// Reference Switch Enable
3306//--------------------------------------
3322#define REFERENCE_SWITCH_ENABLE_LIST(X) \
3323 X(NO_STOP_ON_SWITCH_TRIGGERED, 0, ) \
3324 X(STOP_ON_L, 1, ) \
3325 X(STOP_ON_R, 2, ) \
3326 X(STOP_ON_R_AND_L, 3, ) \
3327 X(STOP_ON_H, 4, ) \
3328 X(STOP_ON_H_AND_L, 5, ) \
3329 X(STOP_ON_H_AND_R, 6, ) \
3330 X(STOP_ON_H_R_AND_L, 7, )
3331
3332enum class ReferenceSwitchEnable : uint8_t {
3333 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3334 REFERENCE_SWITCH_ENABLE_LIST(X)
3335 #undef X
3336};
3337
3338inline const char* to_string(ReferenceSwitchEnable enable) {
3339 switch(enable) {
3340 #define X(NAME, VALUE, DOC) case ReferenceSwitchEnable::NAME: return #NAME;
3341 REFERENCE_SWITCH_ENABLE_LIST(X)
3342 #undef X
3343 default: return "UNKNOWN";
3344 }
3345}
3346#undef REFERENCE_SWITCH_ENABLE_LIST
3348
3351//--------------------------------------
3352// Reference Switch Polarity and Swap
3353//--------------------------------------
3377#define REFERENCE_SWITCH_POLARITY_SWAP_LIST(X) \
3378 X(NOT_SWAPPED_NOT_INVERTED, 0, ) \
3379 X(L_INVERTED, 1, ) \
3380 X(R_INVERTED, 2, ) \
3381 X(R_AND_L_INVERTED, 3, ) \
3382 X(H_INVERTED, 4, ) \
3383 X(H_AND_L_INVERTED, 5, ) \
3384 X(H_AND_R_INVERTED, 6, ) \
3385 X(H_R_AND_L_INVERTED, 7, ) \
3386 X(L_R_SWAPPED_L_INVERTED, 8, ) \
3387 X(L_R_SWAPPED_R_INVERTED, 9, ) \
3388 X(L_R_SWAPPED_R_AND_L_INVERTED, 10, ) \
3389 X(L_R_SWAPPED_H_INVERTED, 11, ) \
3390 X(L_R_SWAPPED_H_AND_L_INVERTED, 12, ) \
3391 X(L_R_SWAPPED, 13, ) \
3392 X(L_R_SWAPPED_H_AND_R_INVERTED, 14, ) \
3393 X(L_R_SWAPPED_H_R_AND_L_INVERTED,15, )
3394
3395enum class ReferenceSwitchPolaritySwap : uint8_t {
3396 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3397 REFERENCE_SWITCH_POLARITY_SWAP_LIST(X)
3398 #undef X
3399};
3400
3401inline const char* to_string(ReferenceSwitchPolaritySwap config) {
3402 switch(config) {
3403 #define X(NAME, VALUE, DOC) case ReferenceSwitchPolaritySwap::NAME: return #NAME;
3404 REFERENCE_SWITCH_POLARITY_SWAP_LIST(X)
3405 #undef X
3406 default: return "UNKNOWN";
3407 }
3408}
3409#undef REFERENCE_SWITCH_POLARITY_SWAP_LIST
3411
3414//--------------------------------------
3415// Reference Switch Latch Settings
3416//--------------------------------------
3440#define REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X) \
3441 X(NO_TRIGGER, 0, ) \
3442 X(L_R_RISING_EDGE, 1, ) \
3443 X(L_R_FALLING_EDGE, 2, ) \
3444 X(L_R_BOTH_EDGES, 3, ) \
3445 X(H_RISING_EDGE, 4, ) \
3446 X(H_L_R_RISING_EDGE, 5, ) \
3447 X(H_RISING_L_R_FALLING_EDGE, 6, ) \
3448 X(H_RISING_L_R_BOTH_EDGES, 7, ) \
3449 X(H_FALLING_EDGE, 8, ) \
3450 X(H_FALLING_L_R_RISING_EDGE, 9, ) \
3451 X(H_L_R_FALLING_EDGE, 10, ) \
3452 X(H_FALLING_L_R_BOTH_EDGES, 11, ) \
3453 X(H_BOTH_EDGES, 12, ) \
3454 X(H_BOTH_L_R_RISING_EDGE, 13, ) \
3455 X(H_BOTH_L_R_FALLING_EDGE, 14, ) \
3456 X(H_L_R_BOTH_EDGES, 15, )
3457
3458enum class ReferenceSwitchLatchSettings : uint8_t {
3459 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3460 REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X)
3461 #undef X
3462};
3463
3464inline const char* to_string(ReferenceSwitchLatchSettings setting) {
3465 switch(setting) {
3466 #define X(NAME, VALUE, DOC) case ReferenceSwitchLatchSettings::NAME: return #NAME;
3467 REFERENCE_SWITCH_LATCH_SETTINGS_LIST(X)
3468 #undef X
3469 default: return "UNKNOWN";
3470 }
3471}
3472#undef REFERENCE_SWITCH_LATCH_SETTINGS_LIST
3474
3477//--------------------------------------
3478// Event Stop Settings
3479//--------------------------------------
3495#define EVENT_STOP_SETTINGS_LIST(X) \
3496 X(DO_HARD_STOP, 0, ) \
3497 X(DO_SOFT_STOP, 1, ) \
3498 X(STOP_ON_POS_DEVIATION, 2, ) \
3499 X(STOP_ON_POS_DEVIATION_SOFT_STOP, 3, ) \
3500 X(STOP_ON_VEL_DEVIATION, 4, ) \
3501 X(STOP_ON_VEL_DEVIATION_SOFT_STOP, 5, ) \
3502 X(STOP_ON_POS_VEL_DEVIATION, 6, ) \
3503 X(STOP_ON_POS_VEL_DEVIATION_SOFT_STOP, 7, )
3504
3505enum class EventStopSettings : uint8_t {
3506 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3507 EVENT_STOP_SETTINGS_LIST(X)
3508 #undef X
3509};
3510
3511inline const char* to_string(EventStopSettings setting) {
3512 switch(setting) {
3513 #define X(NAME, VALUE, DOC) case EventStopSettings::NAME: return #NAME;
3514 EVENT_STOP_SETTINGS_LIST(X)
3515 #undef X
3516 default: return "UNKNOWN";
3517 }
3518}
3519#undef EVENT_STOP_SETTINGS_LIST
3521
3523// //
3524// ██████╗ ██╗ ██████╗ ██╗ ██╗ █████╗ ██████╗ ███████╗██╗██╗ ████████╗███████╗██████╗ //
3525// ██╔══██╗██║██╔═══██╗██║ ██║██╔══██╗██╔══██╗ ██╔════╝██║██║ ╚══██╔══╝██╔════╝██╔══██╗ //
3526// ██████╔╝██║██║ ██║██║ ██║███████║██║ ██║ █████╗ ██║██║ ██║ █████╗ ██████╔╝ //
3527// ██╔══██╗██║██║▄▄ ██║██║ ██║██╔══██║██║ ██║ ██╔══╝ ██║██║ ██║ ██╔══╝ ██╔══██╗ //
3528// ██████╔╝██║╚██████╔╝╚██████╔╝██║ ██║██████╔╝ ██║ ██║███████╗██║ ███████╗██║ ██║ //
3529// ╚═════╝ ╚═╝ ╚══▀▀═╝ ╚═════╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚══════╝╚═╝ ╚═╝ //
3530// //
3531//==================================================================================================================//
3532// BIQUAD FILTER SETUP SECTION //
3533//==================================================================================================================//
3535
3537// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3538// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3539// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3541
3544//--------------------------------------
3545// Biquad Filter Parameters
3546//--------------------------------------
3579#define BIQUAD_FILTER_LIST(X) \
3580 X(TARGET_TORQUE_BIQUAD_FILTER_ENABLE, 318, ) \
3581 X(TARGET_TORQUE_BIQUAD_FILTER_ACOEFF_1, 319, ) \
3582 X(TARGET_TORQUE_BIQUAD_FILTER_ACOEFF_2, 320, ) \
3583 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_0, 321, ) \
3584 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_1, 322, ) \
3585 X(TARGET_TORQUE_BIQUAD_FILTER_BCOEFF_2, 323, ) \
3586 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ENABLE, 324, ) \
3587 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ACOEFF_1, 325, ) \
3588 X(ACTUAL_VELOCITY_BIQUAD_FILTER_ACOEFF_2, 326, ) \
3589 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_0, 327, ) \
3590 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_1, 328, ) \
3591 X(ACTUAL_VELOCITY_BIQUAD_FILTER_BCOEFF_2, 329, )
3592
3593enum class BiquadFilter : uint16_t {
3594 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3595 BIQUAD_FILTER_LIST(X)
3596 #undef X
3597};
3598
3599inline const char* to_string(BiquadFilter e) {
3600 switch(e) {
3601 #define X(NAME, VALUE, DOC) case BiquadFilter::NAME: return #NAME;
3602 BIQUAD_FILTER_LIST(X)
3603 #undef X
3604 default: return "UNKNOWN";
3605 }
3606}
3608
3610// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3611// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3612// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3614
3617//--------------------------------------
3618// Biquad Filter Enable/Disable
3619//--------------------------------------
3629#define BIQUAD_FILTER_ENABLE_LIST(X) \
3630 X(DISABLED, 0, ) \
3631 X(ENABLED, 1, )
3632
3633enum class BiquadFilterEnable : uint8_t {
3634 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3635 BIQUAD_FILTER_ENABLE_LIST(X)
3636 #undef X
3637};
3638
3639inline const char* to_string(BiquadFilterEnable enable) {
3640 switch(enable) {
3641 #define X(NAME, VALUE, DOC) case BiquadFilterEnable::NAME: return #NAME;
3642 BIQUAD_FILTER_ENABLE_LIST(X)
3643 #undef X
3644 default: return "UNKNOWN";
3645 }
3646}
3647#undef BIQUAD_FILTER_ENABLE_LIST
3649
3651// //
3652// ███████╗ █████╗ ██╗ ██╗██╗ ████████╗ ██╗ ██╗ █████╗ ███╗ ██╗██████╗ ██╗ ██╗███╗ ██╗ ██████╗ //
3653// ██╔════╝██╔══██╗██║ ██║██║ ╚══██╔══╝ ██║ ██║██╔══██╗████╗ ██║██╔══██╗██║ ██║████╗ ██║██╔════╝ //
3654// █████╗ ███████║██║ ██║██║ ██║ ███████║███████║██╔██╗ ██║██║ ██║██║ ██║██╔██╗ ██║██║ ███╗ //
3655// ██╔══╝ ██╔══██║██║ ██║██║ ██║ ██╔══██║██╔══██║██║╚██╗██║██║ ██║██║ ██║██║╚██╗██║██║ ██║ //
3656// ██║ ██║ ██║╚██████╔╝███████╗██║ ██║ ██║██║ ██║██║ ╚████║██████╔╝███████╗██║██║ ╚████║╚██████╔╝ //
3657// ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ╚══════╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
3658// //
3659//==================================================================================================================//
3660// FAULT HANDLING SECTION //
3661//==================================================================================================================//
3663
3665// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3666// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3667// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3669
3672//--------------------------------------
3673// Fault Handling Parameters
3674//--------------------------------------
3690#define FAULT_HANDLING_LIST(X) \
3691 X(GDRV_RETRY_BEHAVIOUR, 286, ) \
3692 X(DRIVE_FAULT_BEHAVIOUR, 287, ) \
3693 X(FAULT_HANDLER_NUMBER_OF_RETRIES, 288, )
3694
3695enum class FaultHandling : uint16_t {
3696 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3697 FAULT_HANDLING_LIST(X)
3698 #undef X
3699};
3700
3701inline const char* to_string(FaultHandling config) {
3702 switch(config) {
3703 #define X(NAME, VALUE, DOC) case FaultHandling::NAME: return #NAME;
3704 FAULT_HANDLING_LIST(X)
3705 #undef X
3706 default: return "UNKNOWN";
3707 }
3708}
3710
3712// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
3713// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
3714// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
3716
3719//--------------------------------------
3720// Gate Driver Retry Behaviour
3721//--------------------------------------
3731#define GDRV_RETRY_BEHAVIOUR_LIST(X) \
3732 X(OPEN_CIRCUIT, 0, ) \
3733 X(ELECTRICAL_BRAKING, 1, )
3734
3735enum class GdrvRetryBehaviour : uint8_t {
3736 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3737 GDRV_RETRY_BEHAVIOUR_LIST(X)
3738 #undef X
3739};
3740
3741inline const char* to_string(GdrvRetryBehaviour behaviour) {
3742 switch(behaviour) {
3743 #define X(NAME, VALUE, DOC) case GdrvRetryBehaviour::NAME: return #NAME;
3744 GDRV_RETRY_BEHAVIOUR_LIST(X)
3745 #undef X
3746 default: return "UNKNOWN";
3747 }
3748}
3749#undef GDRV_RETRY_BEHAVIOUR_LIST
3751
3754//--------------------------------------
3755// Drive Fault Behaviour
3756//--------------------------------------
3768#define DRIVE_FAULT_BEHAVIOUR_LIST(X) \
3769 X(OPEN_CIRCUIT, 0, ) \
3770 X(ELECTRICAL_BRAKING, 1, ) \
3771 X(MECHANICAL_BRAKING_AND_OPEN_CIRCUIT,2, ) \
3772 X(MECHANICAL_AND_ELECTRICAL_BRAKING, 3, )
3773
3774enum class DriveFaultBehaviour : std::uint8_t {
3775 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3776 DRIVE_FAULT_BEHAVIOUR_LIST(X)
3777 #undef X
3778};
3779
3780inline const char* to_string(DriveFaultBehaviour behaviour) {
3781 switch(behaviour) {
3782 #define X(NAME, VALUE, DOC) case DriveFaultBehaviour::NAME: return #NAME;
3783 DRIVE_FAULT_BEHAVIOUR_LIST(X)
3784 #undef X
3785 default: return "UNKNOWN";
3786 }
3787}
3788#undef DRIVE_FAULT_BEHAVIOUR_LIST
3790
3792// //
3793// ██╗██╗████████╗ ███╗ ███╗ ██████╗ ███╗ ██╗██╗████████╗ ██████╗ ██████╗ //
3794// ██║██║╚══██╔══╝ ████╗ ████║██╔═══██╗████╗ ██║██║╚══██╔══╝██╔═══██╗██╔══██╗ //
3795// ██║██║ ██║ ██╔████╔██║██║ ██║██╔██╗ ██║██║ ██║ ██║ ██║██████╔╝ //
3796// ██║██║ ██║ ██║╚██╔╝██║██║ ██║██║╚██╗██║██║ ██║ ██║ ██║██╔══██╗ //
3797// ██║██║ ██║ ██║ ╚═╝ ██║╚██████╔╝██║ ╚████║██║ ██║ ╚██████╔╝██║ ██║ //
3798// ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ //
3799// //
3800//==================================================================================================================//
3801// IIT MONITOR SECTION //
3802//==================================================================================================================//
3803
3805// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3806// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3807// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3809
3812//--------------------------------------
3813// IIT Monitor Parameters
3814//--------------------------------------
3843#define IIT_MONITOR_LIST(X) \
3844 X(THERMAL_WINDING_TIME_CONSTANT_1, 224, ) \
3845 X(IIT_LIMIT_1, 225, ) \
3846 X(IIT_SUM_1, 226, ) \
3847 X(THERMAL_WINDING_TIME_CONSTANT_2, 227, ) \
3848 X(IIT_LIMIT_2, 228, ) \
3849 X(IIT_SUM_2, 229, ) \
3850 X(RESET_IIT_SUMS, 230, ) \
3851 X(ACTUAL_TOTAL_MOTOR_CURRENT, 231, )
3852
3853enum class IitMonitor : uint16_t {
3854 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3855 IIT_MONITOR_LIST(X)
3856 #undef X
3857};
3858
3859inline const char* to_string(IitMonitor e) {
3860 switch(e) {
3861 #define X(NAME, VALUE, DOC) case IitMonitor::NAME: return #NAME;
3862 IIT_MONITOR_LIST(X)
3863 #undef X
3864 default: return "UNKNOWN";
3865 }
3866}
3868
3870// //
3871// ████████╗███████╗███╗ ███╗██████╗ ███████╗██████╗ █████╗ ████████╗██╗ ██╗██████╗ ███████╗ //
3872// ╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██║ ██║██╔══██╗██╔════╝ //
3873// ██║ █████╗ ██╔████╔██║██████╔╝█████╗ ██████╔╝███████║ ██║ ██║ ██║██████╔╝█████╗ //
3874// ██║ ██╔══╝ ██║╚██╔╝██║██╔═══╝ ██╔══╝ ██╔══██╗██╔══██║ ██║ ██║ ██║██╔══██╗██╔══╝ //
3875// ██║ ███████╗██║ ╚═╝ ██║██║ ███████╗██║ ██║██║ ██║ ██║ ╚██████╔╝██║ ██║███████╗ //
3876// ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ //
3877// //
3878// ██████╗ ██████╗ ██████╗ ████████╗███████╗ ██████╗████████╗██╗ ██████╗ ███╗ ██╗███████╗ //
3879// ██╔══██╗██╔══██╗██╔═══██╗╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝██║██╔═══██╗████╗ ██║██╔════╝ //
3880// ██████╔╝██████╔╝██║ ██║ ██║ █████╗ ██║ ██║ ██║██║ ██║██╔██╗ ██║███████╗ //
3881// ██╔═══╝ ██╔══██╗██║ ██║ ██║ ██╔══╝ ██║ ██║ ██║██║ ██║██║╚██╗██║╚════██║ //
3882// ██║ ██║ ██║╚██████╔╝ ██║ ███████╗╚██████╗ ██║ ██║╚██████╔╝██║ ╚████║███████║ //
3883// ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ //
3884// //
3885//==================================================================================================================//
3886// TEMPERATURE PROTECTIONS SECTION //
3887//==================================================================================================================//
3890// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3891// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3892// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3894
3897//--------------------------------------
3898// Temperature Protection Parameters
3899//--------------------------------------
3920#define TEMPERATURE_PROTECTION_LIST(X) \
3921 X(EXTERNAL_TEMPERATURE, 293, ) \
3922 X(EXTERNAL_TEMPERATURE_SHUTDOWN_THRESHOLD, 294, ) \
3923 X(EXTERNAL_TEMPERATURE_WARNING_THRESHOLD, 295, ) \
3924 X(CHIP_TEMPERATURE, 296, ) \
3925 X(CHIP_TEMPERATURE_SHUTDOWN_THRESHOLD, 297, ) \
3926 X(CHIP_TEMPERATURE_WARNING_THRESHOLD, 298, )
3927
3928enum class TemperatureProtection : uint16_t {
3929 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3930 TEMPERATURE_PROTECTION_LIST(X)
3931 #undef X
3932};
3933
3934inline const char* to_string(TemperatureProtection e) {
3935 switch(e) {
3936 #define X(NAME, VALUE, DOC) case TemperatureProtection::NAME: return #NAME;
3937 TEMPERATURE_PROTECTION_LIST(X)
3938 #undef X
3939 default: return "UNKNOWN";
3940 }
3941}
3943
3945// //
3946// ██╗ ██╗███████╗ █████╗ ██████╗ ████████╗██████╗ ███████╗ █████╗ ████████╗ //
3947// ██║ ██║██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██╔══██╗██╔════╝██╔══██╗╚══██╔══╝ //
3948// ███████║█████╗ ███████║██████╔╝ ██║ ██████╔╝█████╗ ███████║ ██║ //
3949// ██╔══██║██╔══╝ ██╔══██║██╔══██╗ ██║ ██╔══██╗██╔══╝ ██╔══██║ ██║ //
3950// ██║ ██║███████╗██║ ██║██║ ██║ ██║ ██████╔╝███████╗██║ ██║ ██║ //
3951// ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ //
3952// //
3953// ███╗ ███╗ ██████╗ ███╗ ██╗██╗████████╗ ██████╗ ██████╗ ██╗███╗ ██╗ ██████╗ //
3954// ████╗ ████║██╔═══██╗████╗ ██║██║╚══██╔══╝██╔═══██╗██╔══██╗██║████╗ ██║██╔════╝ //
3955// ██╔████╔██║██║ ██║██╔██╗ ██║██║ ██║ ██║ ██║██████╔╝██║██╔██╗ ██║██║ ███╗ //
3956// ██║╚██╔╝██║██║ ██║██║╚██╗██║██║ ██║ ██║ ██║██╔══██╗██║██║╚██╗██║██║ ██║ //
3957// ██║ ╚═╝ ██║╚██████╔╝██║ ╚████║██║ ██║ ╚██████╔╝██║ ██║██║██║ ╚████║╚██████╔╝ //
3958// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
3959// //
3960//==================================================================================================================//
3961// HEARTBEAT MONITORING SECTION //
3962//==================================================================================================================//
3964
3966// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
3967// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
3968// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
3970
3973//--------------------------------------
3974// Heartbeat Monitoring Parameters
3975//--------------------------------------
3989#define HEARTBEAT_MONITORING_LIST(X) \
3990 X(HEARTBEAT_MONITORING_CONFIG, 3, ) \
3991 X(HEARTBEAT_MONITORING_TIMEOUT, 4, )
3992
3993enum class HeartbeatMonitoring : uint16_t {
3994 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
3995 HEARTBEAT_MONITORING_LIST(X)
3996 #undef X
3997};
3998
3999inline const char* to_string(HeartbeatMonitoring e) {
4000 switch(e) {
4001 #define X(NAME, VALUE, DOC) case HeartbeatMonitoring::NAME: return #NAME;
4002 HEARTBEAT_MONITORING_LIST(X)
4003 #undef X
4004 default: return "UNKNOWN";
4005 }
4006}
4008
4010// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4011// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4012// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4014
4017//--------------------------------------
4018// Heartbeat Monitoring Config
4019//--------------------------------------
4031#define HEARTBEAT_MONITORING_CONFIG_LIST(X) \
4032 X(DISABLED, 0, ) \
4033 X(TMCL_UART_INTERFACE, 1, ) \
4034 X(SPI_INTERFACE, 2, ) \
4035 X(TMCL_UART_AND_SPI_INTERFACE, 3, )
4036
4037enum class HeartbeatMonitoringConfig : uint8_t {
4038 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4039 HEARTBEAT_MONITORING_CONFIG_LIST(X)
4040 #undef X
4041};
4042
4043inline const char* to_string(HeartbeatMonitoringConfig e) {
4044 switch(e) {
4045 #define X(NAME, VALUE, DOC) case HeartbeatMonitoringConfig::NAME: return #NAME;
4046 HEARTBEAT_MONITORING_CONFIG_LIST(X)
4047 #undef X
4048 default: return "UNKNOWN";
4049 }
4050}
4051#undef HEARTBEAT_MONITORING_CONFIG_LIST
4053
4054
4056// //
4057// ██████╗ ██████╗ █████╗ ██╗ ██╗███████╗ ██████╗██╗ ██╗ ██████╗ ██████╗ ██████╗ ███████╗██████╗ //
4058// ██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝██╔════╝ ██╔════╝██║ ██║██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗ //
4059// ██████╔╝██████╔╝███████║█████╔╝ █████╗ ██║ ███████║██║ ██║██████╔╝██████╔╝█████╗ ██████╔╝ //
4060// ██╔══██╗██╔══██╗██╔══██║██╔═██╗ ██╔══╝ ██║ ██╔══██║██║ ██║██╔═══╝ ██╔═══╝ ██╔══╝ ██╔══██╗ //
4061// ██████╔╝██║ ██║██║ ██║██║ ██╗███████╗ ╚██████╗██║ ██║╚██████╔╝██║ ██║ ███████╗██║ ██║ //
4062// ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ //
4063// //
4064//==================================================================================================================//
4065// BRAKE CHOPPER SECTION //
4066//==================================================================================================================//
4068
4070// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4071// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4072// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4074
4077//--------------------------------------
4078// Brake Chopper Parameters
4079//--------------------------------------
4095#define BRAKE_CHOPPER_LIST(X) \
4096 X(BRAKE_CHOPPER_ENABLE, 212, ) \
4097 X(BRAKE_CHOPPER_VOLTAGE_LIMIT, 213, ) \
4098 X(BRAKE_CHOPPER_HYSTERESIS, 214, )
4099
4100enum class BrakeChopper : uint16_t {
4101 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4102 BRAKE_CHOPPER_LIST(X)
4103 #undef X
4104};
4105
4106inline const char* to_string(BrakeChopper e) {
4107 switch(e) {
4108 #define X(NAME, VALUE, DOC) case BrakeChopper::NAME: return #NAME;
4109 BRAKE_CHOPPER_LIST(X)
4110 #undef X
4111 default: return "UNKNOWN";
4112 }
4113}
4115
4117// //
4118// ███╗ ███╗███████╗ ██████╗██╗ ██╗ █████╗ ███╗ ██╗██╗ ██████╗ █████╗ ██╗ //
4119// ████╗ ████║██╔════╝██╔════╝██║ ██║██╔══██╗████╗ ██║██║██╔════╝██╔══██╗██║ //
4120// ██╔████╔██║█████╗ ██║ ███████║███████║██╔██╗ ██║██║██║ ███████║██║ //
4121// ██║╚██╔╝██║██╔══╝ ██║ ██╔══██║██╔══██║██║╚██╗██║██║██║ ██╔══██║██║ //
4122// ██║ ╚═╝ ██║███████╗╚██████╗██║ ██║██║ ██║██║ ╚████║██║╚██████╗██║ ██║███████╗ //
4123// ╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═════╝╚═╝ ╚═╝╚══════╝ //
4124// //
4125// ██████╗ ██████╗ █████╗ ██╗ ██╗███████╗ //
4126// ██╔══██╗██╔══██╗██╔══██╗██║ ██╔╝██╔════╝ //
4127// ██████╔╝██████╔╝███████║█████╔╝ █████╗ //
4128// ██╔══██╗██╔══██╗██╔══██║██╔═██╗ ██╔══╝ //
4129// ██████╔╝██║ ██║██║ ██║██║ ██╗███████╗ //
4130// ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
4131// //
4132//==================================================================================================================//
4133// MECHANICAL BRAKE SECTION //
4134//==================================================================================================================//
4136
4138// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4139// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4140// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4142
4145//--------------------------------------
4146// Mechanical Brake Parameters
4147//--------------------------------------
4166#define MECHANICAL_BRAKE_LIST(X) \
4167 X(RELEASE_BRAKE, 216, ) \
4168 X(BRAKE_RELEASING_DUTY_CYCLE, 217, ) \
4169 X(BRAKE_HOLDING_DUTY_CYCLE, 218, ) \
4170 X(BRAKE_RELEASING_DURATION, 219, ) \
4171 X(INVERT_BRAKE_OUTPUT, 221, )
4172
4173enum class MechanicalBrake : uint16_t {
4174 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4175 MECHANICAL_BRAKE_LIST(X)
4176 #undef X
4177};
4178
4179inline const char* to_string(MechanicalBrake e) {
4180 switch(e) {
4181 #define X(NAME, VALUE, DOC) case MechanicalBrake::NAME: return #NAME;
4182 MECHANICAL_BRAKE_LIST(X)
4183 #undef X
4184 default: return "UNKNOWN";
4185 }
4186}
4188
4190// //
4191// █████╗ ██╗ ██╗████████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██████╗ //
4192// ██╔══██╗██║ ██║╚══██╔══╝██╔═══██╗████╗ ████║██╔══██╗╚══██╔══╝██║██╔════╝ //
4193// ███████║██║ ██║ ██║ ██║ ██║██╔████╔██║███████║ ██║ ██║██║ //
4194// ██╔══██║██║ ██║ ██║ ██║ ██║██║╚██╔╝██║██╔══██║ ██║ ██║██║ //
4195// ██║ ██║╚██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║╚██████╗ //
4196// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ //
4197// //
4198// ██╗ ██╗ ██████╗ ███╗ ███╗██╗███╗ ██╗ ██████╗ //
4199// ██║ ██║██╔═══██╗████╗ ████║██║████╗ ██║██╔════╝ //
4200// ███████║██║ ██║██╔████╔██║██║██╔██╗ ██║██║ ███╗ //
4201// ██╔══██║██║ ██║██║╚██╔╝██║██║██║╚██╗██║██║ ██║ //
4202// ██║ ██║╚██████╔╝██║ ╚═╝ ██║██║██║ ╚████║╚██████╔╝ //
4203// ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═══╝ ╚═════╝ //
4204// //
4205//==================================================================================================================//
4206// AUTOMATIC HOMING SECTION //
4207//==================================================================================================================//
4209
4211// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4212// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4213// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4215
4218//--------------------------------------
4219// Reference Search (Automatic Homing) Parameters
4220//--------------------------------------
4238#define REFERENCE_SEARCH_LIST(X) \
4239 X(REFERENCE_SWITCH_SEARCH_MODE, 165, ) \
4240 X(REFERENCE_SWITCH_SEARCH_SPEED, 166, ) \
4241 X(REFERENCE_SWITCH_SPEED, 167, ) \
4242 X(RIGHT_LIMIT_SWITCH_POSITION, 168, ) \
4243 X(HOME_SWITCH_POSITION, 169, ) \
4244 X(LAST_REFERENCE_POSITION, 170, )
4245
4246enum class ReferenceSearch : uint16_t {
4247 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4248 REFERENCE_SEARCH_LIST(X)
4249 #undef X
4250};
4251
4252inline const char* to_string(ReferenceSearch e) {
4253 switch(e) {
4254 #define X(NAME, VALUE, DOC) case ReferenceSearch::NAME: return #NAME;
4255 REFERENCE_SEARCH_LIST(X)
4256 #undef X
4257 default: return "UNKNOWN";
4258 }
4259}
4261
4263// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4264// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4265// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4267
4270//--------------------------------------
4271// Reference Search Modes
4272//--------------------------------------
4288#define REFERENCE_SEARCH_MODE_LIST(X) \
4289 X(LEFT_SWITCH, 1, ) \
4290 X(RIGHT_SWITCH_LEFT_SWITCH, 2, ) \
4291 X(RIGHT_SWITCH_LEFT_SWITCH_BOTH_SIDES, 3, ) \
4292 X(LEFT_SWITCH_BOTH_SIDES, 4, ) \
4293 X(HOME_SWITCH_NEG_DIR_LEFT_END_SWITCH, 5, ) \
4294 X(HOME_SWITCH_POS_DIR_RIGHT_END_SWITCH, 6, ) \
4295 X(HOME_SWITCH_NEG_DIR_IGNORE_END_SWITCH, 7, ) \
4296 X(HOME_SWITCH_POS_DIR_IGNORE_END_SWITCH, 8, )
4297
4298enum class ReferenceSwitchSearchMode : uint8_t {
4299 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4300 REFERENCE_SEARCH_MODE_LIST(X)
4301 #undef X
4302};
4303
4304inline const char* to_string(ReferenceSwitchSearchMode e) {
4305 switch(e) {
4306 #define X(NAME, VALUE, DOC) case ReferenceSwitchSearchMode::NAME: return #NAME;
4307 REFERENCE_SEARCH_MODE_LIST(X)
4308 #undef X
4309 default: return "UNKNOWN";
4310 }
4311}
4312#undef REFERENCE_SEARCH_MODE_LIST
4314
4317//--------------------------------------
4318// Reference Search TMCL Command Types
4319//--------------------------------------
4330#define REFERENCE_SEARCH_COMMAND_LIST(X) \
4331 X(START, 0, ) \
4332 X(STOP, 1, ) \
4333 X(STATUS, 2, )
4334
4335enum class ReferenceSearchCommand : uint8_t {
4336 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4337 REFERENCE_SEARCH_COMMAND_LIST(X)
4338 #undef X
4339};
4340
4341inline const char* to_string(ReferenceSearchCommand e) {
4342 switch(e) {
4343 #define X(NAME, VALUE, DOC) case ReferenceSearchCommand::NAME: return #NAME;
4344 REFERENCE_SEARCH_COMMAND_LIST(X)
4345 #undef X
4346 default: return "UNKNOWN";
4347 }
4348}
4349#undef REFERENCE_SEARCH_COMMAND_LIST
4351
4354//--------------------------------------
4355// Reference Search Status Codes
4356//--------------------------------------
4380#define REFERENCE_SEARCH_STATUS_LIST(X) \
4381 X(IDLE, 0, ) \
4382 X(START_REFERENCE_DRIVE, 1, ) \
4383 X(START_DRIVE_TO_RIGHT_LIMIT_FAST, 2, ) \
4384 X(WAIT_UNTIL_RIGHT_SWITCH_REACHED, 3, ) \
4385 X(START_DRIVE_TO_LEFT_LIMIT_FAST, 4, ) \
4386 X(WAIT_UNTIL_LEFT_SWITCH_REACHED, 5, ) \
4387 X(DRIVE_OUT_OF_LEFT_SWITCH_SLOWLY, 6, ) \
4388 X(WAIT_UNTIL_LEFT_SWITCH_EXITED_DRIVE_IN_AGAIN, 7, ) \
4389 X(WAIT_UNTIL_LEFT_SWITCH_REACHED_AGAIN_DRIVE_TO_POSITION, 8, ) \
4390 X(WAIT_UNTIL_POSITION_REACHED_SET_ZERO, 9, ) \
4391 X(WAIT_UNTIL_SWITCH_PUSHED_AGAIN, 10, ) \
4392 X(WAIT_UNTIL_OTHER_SIDE_SWITCH_REACHED, 11, ) \
4393 X(RESERVED, 12, ) \
4394 X(WAIT_UNTIL_CENTER_SWITCH_REACHED, 13, ) \
4395 X(REFERENCE_DRIVE_FINISHED_RESTORE_SETTINGS, 14, ) \
4396 X(STOP_REFERENCE_DRIVE, 15, )
4397
4398enum class ReferenceSearchStatus : uint8_t {
4399 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4400 REFERENCE_SEARCH_STATUS_LIST(X)
4401 #undef X
4402};
4403
4404inline const char* to_string(ReferenceSearchStatus e) {
4405 switch(e) {
4406 #define X(NAME, VALUE, DOC) case ReferenceSearchStatus::NAME: return #NAME;
4407 REFERENCE_SEARCH_STATUS_LIST(X)
4408 #undef X
4409 default: return "UNKNOWN";
4410 }
4411}
4412#undef REFERENCE_SEARCH_STATUS_LIST
4414
4416// //
4417// ███████╗████████╗███████╗██████╗ ██╗██████╗ ██╗██████╗ //
4418// ██╔════╝╚══██╔══╝██╔════╝██╔══██╗ ██╔╝██╔══██╗██║██╔══██╗ //
4419// ███████╗ ██║ █████╗ ██████╔╝ ██╔╝ ██║ ██║██║██████╔╝ //
4420// ╚════██║ ██║ ██╔══╝ ██╔═══╝ ██╔╝ ██║ ██║██║██╔══██╗ //
4421// ███████║ ██║ ███████╗██║ ██╔╝ ██████╔╝██║██║ ██║ //
4422// ╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝╚═╝ ╚═╝ //
4423// //
4424//==================================================================================================================//
4425// STEP/DIR SECTION //
4426//==================================================================================================================//
4428
4430// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4431// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4432// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4436//--------------------------------------
4437// Step/Dir Interface Parameters
4438//--------------------------------------
4455#define STEP_DIR_LIST(X) \
4456 /* VELOCITY_FEEDFORWARD_ENABLE defined in VELOCITY_CONTROL_LIST */ \
4457 X(STEP_DIR_STEP_DIVIDER_SHIFT, 205, ) \
4458 X(STEP_DIR_ENABLE, 206, ) \
4459 X(STEP_DIR_EXTRAPOLATION_ENABLE, 207, ) \
4460 X(STEP_DIR_STEP_SIGNAL_TIMEOUT_LIMIT, 208, ) \
4461 X(STEP_DIR_MAXIMUM_EXTRAPOLATION_VELOCITY, 209, )
4462
4463enum class StepDir : uint16_t {
4464 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4465 STEP_DIR_LIST(X)
4466 #undef X
4467};
4468
4469inline const char* to_string(StepDir e) {
4470 switch(e) {
4471 #define X(NAME, VALUE, DOC) case StepDir::NAME: return #NAME;
4472 STEP_DIR_LIST(X)
4473 #undef X
4474 default: return "UNKNOWN";
4475 }
4476}
4478
4480// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4481// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4482// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4484
4487//--------------------------------------
4488// Step/Dir Microstep Divider Shift
4489//--------------------------------------
4509#define STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X) \
4510 X(STEP_MODE_FULL, 0, ) \
4511 X(STEP_MODE_HALF, 1, ) \
4512 X(STEP_MODE_QUARTER, 2, ) \
4513 X(STEP_MODE_1_8TH, 3, ) \
4514 X(STEP_MODE_1_16TH, 4, ) \
4515 X(STEP_MODE_1_32ND, 5, ) \
4516 X(STEP_MODE_1_64TH, 6, ) \
4517 X(STEP_MODE_1_128TH, 7, ) \
4518 X(STEP_MODE_1_256TH, 8, ) \
4519 X(STEP_MODE_1_512TH, 9, ) \
4520 X(STEP_MODE_1_1024TH, 10, )
4521
4522enum class StepDirStepDividerShift : uint8_t {
4523 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4524 STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X)
4525 #undef X
4526};
4527
4528inline const char* to_string(StepDirStepDividerShift e) {
4529 switch(e) {
4530 #define X(NAME, VALUE, DOC) case StepDirStepDividerShift::NAME: return #NAME;
4531 STEP_DIR_STEP_DIVIDER_SHIFT_LIST(X)
4532 #undef X
4533 default: return "UNKNOWN";
4534 }
4535}
4536#undef STEP_DIR_STEP_DIVIDER_SHIFT_LIST
4538
4540// //
4541// ██╗ ██╗██╗██████╗ ███████╗██████╗ ███╗ ██╗ █████╗ ████████╗██╗ ██████╗ ███╗ ██╗ //
4542// ██║ ██║██║██╔══██╗██╔════╝██╔══██╗████╗ ██║██╔══██╗╚══██╔══╝██║██╔═══██╗████╗ ██║ //
4543// ███████║██║██████╔╝█████╗ ██████╔╝██╔██╗ ██║███████║ ██║ ██║██║ ██║██╔██╗ ██║ //
4544// ██╔══██║██║██╔══██╗██╔══╝ ██╔══██╗██║╚██╗██║██╔══██║ ██║ ██║██║ ██║██║╚██╗██║ //
4545// ██║ ██║██║██████╔╝███████╗██║ ██║██║ ╚████║██║ ██║ ██║ ██║╚██████╔╝██║ ╚████║ //
4546// ╚═╝ ╚═╝╚═╝╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ //
4547// //
4548// █████╗ ███╗ ██╗██████╗ ██╗ ██╗ █████╗ ██╗ ██╗███████╗██╗ ██╗██████╗ //
4549// ██╔══██╗████╗ ██║██╔══██╗ ██║ ██║██╔══██╗██║ ██╔╝██╔════╝██║ ██║██╔══██╗ //
4550// ███████║██╔██╗ ██║██║ ██║ ██║ █╗ ██║███████║█████╔╝ █████╗ ██║ ██║██████╔╝ //
4551// ██╔══██║██║╚██╗██║██║ ██║ ██║███╗██║██╔══██║██╔═██╗ ██╔══╝ ██║ ██║██╔═══╝ //
4552// ██║ ██║██║ ╚████║██████╔╝ ╚███╔███╔╝██║ ██║██║ ██╗███████╗╚██████╔╝██║ //
4553// ╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ╚══╝╚══╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ //
4554// //
4555//==================================================================================================================//
4556// HIBERNATION AND WAKEUP SECTION //
4557//==================================================================================================================//
4559
4561// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4562// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4563// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4565
4568//--------------------------------------
4569// Hibernation and Wakeup Parameters
4570//--------------------------------------
4585#define HIBERNATION_WAKEUP_LIST(X) \
4586 X(WAKE_PIN_CONTROL_ENABLE, 10, ) \
4587 X(GO_TO_TIMEOUT_POWER_DOWN_STATE, 11, )
4588
4589enum class HibernationWakeup : uint16_t {
4590 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4591 HIBERNATION_WAKEUP_LIST(X)
4592 #undef X
4593};
4594
4595inline const char* to_string(HibernationWakeup e) {
4596 switch(e) {
4597 #define X(NAME, VALUE, DOC) case HibernationWakeup::NAME: return #NAME;
4598 HIBERNATION_WAKEUP_LIST(X)
4599 #undef X
4600 default: return "UNKNOWN";
4601 }
4602}
4603
4605// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4606// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4607// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4609
4612//--------------------------------------
4613// Power Down Timeout
4614//--------------------------------------
4630#define POWER_DOWN_TIMEOUT_LIST(X) \
4631 X(T_250_MILLISEC, 0, ) \
4632 X(T_500_MILLISEC, 1, ) \
4633 X(T_1_SEC, 2, ) \
4634 X(T_2_SEC, 3, ) \
4635 X(T_4_SEC, 4, ) \
4636 X(T_8_SEC, 5, ) \
4637 X(T_16_SEC, 6, ) \
4638 X(T_32_SEC, 7, )
4639
4640enum class PowerDownTimeout : uint8_t {
4641 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4642 POWER_DOWN_TIMEOUT_LIST(X)
4643 #undef X
4644};
4645
4646inline const char* to_string(PowerDownTimeout e) {
4647 switch(e) {
4648 #define X(NAME, VALUE, DOC) case PowerDownTimeout::NAME: return #NAME;
4649 POWER_DOWN_TIMEOUT_LIST(X)
4650 #undef X
4651 default: return "UNKNOWN";
4652 }
4653}
4654#undef POWER_DOWN_TIMEOUT_LIST
4655
4657// //
4658// ██╗███╗ ██╗████████╗███████╗██████╗ ███╗ ██╗ █████╗ ██╗ //
4659// ██║████╗ ██║╚══██╔══╝██╔════╝██╔══██╗████╗ ██║██╔══██╗██║ //
4660// ██║██╔██╗ ██║ ██║ █████╗ ██████╔╝██╔██╗ ██║███████║██║ //
4661// ██║██║╚██╗██║ ██║ ██╔══╝ ██╔══██╗██║╚██╗██║██╔══██║██║ //
4662// ██║██║ ╚████║ ██║ ███████╗██║ ██║██║ ╚████║██║ ██║███████╗ //
4663// ╚═╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝ //
4664// //
4665// ███╗ ███╗███████╗ █████╗ ███████╗██╗ ██╗██████╗ ███████╗███╗ ███╗███████╗███╗ ██╗████████╗███████╗ //
4666// ████╗ ████║██╔════╝██╔══██╗██╔════╝██║ ██║██╔══██╗██╔════╝████╗ ████║██╔════╝████╗ ██║╚══██╔══╝██╔════╝ //
4667// ██╔████╔██║█████╗ ███████║███████╗██║ ██║██████╔╝█████╗ ██╔████╔██║█████╗ ██╔██╗ ██║ ██║ ███████╗ //
4668// ██║╚██╔╝██║██╔══╝ ██╔══██║╚════██║██║ ██║██╔══██╗██╔══╝ ██║╚██╔╝██║██╔══╝ ██║╚██╗██║ ██║ ╚════██║ //
4669// ██║ ╚═╝ ██║███████╗██║ ██║███████║╚██████╔╝██║ ██║███████╗██║ ╚═╝ ██║███████╗██║ ╚████║ ██║ ███████║ //
4670// ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝ ╚═╝ ╚══════╝ //
4671// //
4672//==================================================================================================================//
4673// INTERNAL MEASUREMENTS SECTION //
4674//==================================================================================================================//
4676
4678// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4679// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4680// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4682
4688
4697#define SYSTEM_STATUS_SUPPLY_LIST(X) \
4698 X(SUPPLY_VOLTAGE, 290, ) \
4699 X(SUPPLY_OVERVOLTAGE_WARNING_THRESHOLD, 291, ) \
4700 X(SUPPLY_UNDERVOLTAGE_WARNING_THRESHOLD, 292, )
4701
4702enum class SystemStatusSupply : uint16_t {
4703 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4704 SYSTEM_STATUS_SUPPLY_LIST(X)
4705 #undef X
4706};
4707
4708inline const char* to_string(SystemStatusSupply e) {
4709 switch(e) {
4710 #define X(NAME, VALUE, DOC) case SystemStatusSupply::NAME: return #NAME;
4711 SYSTEM_STATUS_SUPPLY_LIST(X)
4712 #undef X
4713 default: return "UNKNOWN";
4714 }
4715}
4717
4719// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4720// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4721// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4723
4729
4749#define INTERNAL_MEASUREMENT_LIST(X) \
4750 X(MCC_INPUTS_RAW, 304, ) \
4751 X(FOC_VOLTAGE_UX, 305, ) \
4752 X(FOC_VOLTAGE_WY, 306, ) \
4753 X(FOC_VOLTAGE_V, 307, ) \
4754 /* FIELDWEAKENING_I and FIELDWEAKENING_VOLTAGE_THRESHOLD defined in TORQUE_FLUX_CONTROL_LIST */ \
4755 X(FOC_CURRENT_UX, 311, ) \
4756 X(FOC_CURRENT_V, 312, ) \
4757 X(FOC_CURRENT_WY, 313, ) \
4758 X(FOC_VOLTAGE_UQ, 314, ) \
4759 X(FOC_CURRENT_IQ, 315, )
4760
4761enum class InternalMeasurement : uint16_t {
4762 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4763 INTERNAL_MEASUREMENT_LIST(X)
4764 #undef X
4765};
4766
4767inline const char* to_string(InternalMeasurement e) {
4768 switch(e) {
4769 #define X(NAME, VALUE, DOC) case InternalMeasurement::NAME: return #NAME;
4770 INTERNAL_MEASUREMENT_LIST(X)
4771 #undef X
4772 default: return "UNKNOWN";
4773 }
4774}
4776
4778// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4779// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4780// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4782
4788
4803#define COMBINED_DIAGNOSTIC_VALUES_LIST(X) \
4804 X(TORQUE_FLUX_COMBINED_TARGET_VALUES, 330, ) \
4805 X(TORQUE_FLUX_COMBINED_ACTUAL_VALUES, 331, ) \
4806 X(VOLTAGE_D_Q_COMBINED_ACTUAL_VALUES, 332, ) \
4807 X(INTEGRATED_ACTUAL_TORQUE_VALUE, 333, ) \
4808 X(INTEGRATED_ACTUAL_VELOCITY_VALUE, 334, )
4809
4810enum class CombinedDiagnosticValues : uint16_t {
4811 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4812 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
4813 #undef X
4814};
4815
4816inline const char* to_string(CombinedDiagnosticValues e) {
4817 switch(e) {
4818 #define X(NAME, VALUE, DOC) case CombinedDiagnosticValues::NAME: return #NAME;
4819 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
4820 #undef X
4821 default: return "UNKNOWN";
4822 }
4823}
4825
4827// //
4828// ███████╗██████╗ ██████╗ ██████╗ ██████╗ ███████╗ ███████╗██╗ █████╗ ██████╗ ███████╗ //
4829// ██╔════╝██╔══██╗██╔══██╗██╔═══██╗██╔══██╗██╔════╝ ██╔════╝██║ ██╔══██╗██╔════╝ ██╔════╝ //
4830// █████╗ ██████╔╝██████╔╝██║ ██║██████╔╝███████╗ █████╗ █████╗ ██║ ███████║██║ ███╗███████╗ //
4831// ██╔══╝ ██╔══██╗██╔══██╗██║ ██║██╔══██╗╚════██║ ╚════╝ ██╔══╝ ██║ ██╔══██║██║ ██║╚════██║ //
4832// ███████╗██║ ██║██║ ██║╚██████╔╝██║ ██║███████║ ██║ ███████╗██║ ██║╚██████╔╝███████║ //
4833// ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚══════╝ //
4834// //
4835//==================================================================================================================//
4836// ERRORS & FLAGS SECTION //
4837//==================================================================================================================//
4839
4841// ╔═╗╔═╗╦═╗╔═╗╔╦╗╔═╗╔╦╗╔═╗╦═╗╔═╗ //
4842// ╠═╝╠═╣╠╦╝╠═╣║║║║╣ ║ ║╣ ╠╦╝╚═╗ //
4843// ╩ ╩ ╩╩╚═╩ ╩╩ ╩╚═╝ ╩ ╚═╝╩╚═╚═╝ //
4845
4848//--------------------------------------
4849// Temperature and Error Flags Parameters
4850//--------------------------------------
4867#define ERRORS_AND_FLAGS_LIST(X) \
4868 X(GENERAL_STATUS_FLAGS, 289, ) \
4869 /* Temperature parameters defined in TEMPERATURE_PROTECTION_LIST */ \
4870 X(GENERAL_ERROR_FLAGS, 299, ) \
4871 X(GDRV_ERROR_FLAGS, 300, ) \
4872 X(ADC_STATUS_FLAGS, 301, )
4873
4874enum class ErrorsAndFlags : uint16_t {
4875 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4876 ERRORS_AND_FLAGS_LIST(X)
4877 #undef X
4878};
4879
4880inline const char* to_string(ErrorsAndFlags e) {
4881 switch(e) {
4882 #define X(NAME, VALUE, DOC) case ErrorsAndFlags::NAME: return #NAME;
4883 ERRORS_AND_FLAGS_LIST(X)
4884 #undef X
4885 default: return "UNKNOWN";
4886 }
4887}
4889
4891// ╔═╗╔╗╔╦ ╦╔╦╗╔═╗╦═╗╔═╗╔╦╗╦╔═╗╔╗╔╔═╗ //
4892// ║╣ ║║║║ ║║║║║╣ ╠╦╝╠═╣ ║ ║║ ║║║║╚═╗ //
4893// ╚═╝╝╚╝╚═╝╩ ╩╚═╝╩╚═╩ ╩ ╩ ╩╚═╝╝╚╝╚═╝ //
4895
4896#define FLAG(bit) (1u << (bit))
4900//--------------------------------------
4901// General Status Flags
4902//--------------------------------------
4946#define GENERAL_STATUS_FLAGS_LIST(X) \
4947 X(REGULATION_STOPPED, FLAG(0), ) \
4948 X(REGULATION_TORQUE, FLAG(1), ) \
4949 X(REGULATION_VELOCITY, FLAG(2), ) \
4950 X(REGULATION_POSITION, FLAG(3), ) \
4951 X(CONFIG_STORED, FLAG(4), ) \
4952 X(CONFIG_LOADED, FLAG(5), ) \
4953 X(CONFIG_READ_ONLY, FLAG(6), ) \
4954 X(TMCL_SCRIPT_READ_ONLY, FLAG(7), ) \
4955 X(BRAKE_CHOPPER_ACTIVE, FLAG(8), ) \
4956 X(POSITION_REACHED, FLAG(9), ) \
4957 X(VELOCITY_REACHED, FLAG(10), ) \
4958 X(ADC_OFFSET_CALIBRATED, FLAG(11), ) \
4959 X(RAMPER_LATCHED, FLAG(12), ) \
4960 X(RAMPER_EVENT_STOP_SWITCH, FLAG(13), ) \
4961 X(RAMPER_EVENT_STOP_DEVIATION, FLAG(14), ) \
4962 X(RAMPER_VELOCITY_REACHED, FLAG(15), ) \
4963 X(RAMPER_POSITION_REACHED, FLAG(16), ) \
4964 X(RAMPER_SECOND_MOVE, FLAG(17), ) \
4965 X(IIT_1_ACTIVE, FLAG(18), ) \
4966 X(IIT_2_ACTIVE, FLAG(19), ) \
4967 X(REFSEARCH_FINISHED, FLAG(20), ) \
4968 X(Y2_USED_FOR_BRAKING, FLAG(21), ) \
4969 X(STEPDIR_INPUT_AVAILABLE, FLAG(23), ) \
4970 X(RIGHT_REF_SWITCH_AVAILABLE, FLAG(24), ) \
4971 X(HOME_REF_SWITCH_AVAILABLE, FLAG(25), ) \
4972 X(LEFT_REF_SWITCH_AVAILABLE, FLAG(26), ) \
4973 X(ABN2_FEEDBACK_AVAILABLE, FLAG(27), ) \
4974 X(HALL_FEEDBACK_AVAILABLE, FLAG(28), ) \
4975 X(ABN1_FEEDBACK_AVAILABLE, FLAG(29), ) \
4976 X(SPI_FLASH_AVAILABLE, FLAG(30), ) \
4977 X(I2C_EEPROM_AVAILABLE, FLAG(31), )
4978
4979enum class GeneralStatusFlags : uint32_t {
4980 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
4981 GENERAL_STATUS_FLAGS_LIST(X)
4982 #undef X
4983};
4984
4985inline const char* to_string(GeneralStatusFlags e) {
4986 switch(e) {
4987 #define X(NAME, VALUE, DOC) case GeneralStatusFlags::NAME: return #NAME;
4988 GENERAL_STATUS_FLAGS_LIST(X)
4989 #undef X
4990 default: return "UNKNOWN";
4991 }
4992}
4993#undef GENERAL_STATUS_FLAGS_LIST
4995
4998//--------------------------------------
4999// General Error Flags
5000//--------------------------------------
5028#define GENERAL_ERROR_FLAGS_LIST(X) \
5029 X(CONFIG_ERROR, FLAG(0), ) \
5030 X(TMCL_SCRIPT_ERROR, FLAG(1), ) \
5031 X(HOMESWITCH_NOT_FOUND, FLAG(2), ) \
5032 X(HALL_ERROR, FLAG(5), ) \
5033 X(WATCHDOG_EVENT, FLAG(9), ) \
5034 X(EXT_TEMP_EXCEEDED, FLAG(13), ) \
5035 X(CHIP_TEMP_EXCEEDED, FLAG(14), ) \
5036 X(I2T_1_EXCEEDED, FLAG(16), ) \
5037 X(I2T_2_EXCEEDED, FLAG(17), ) \
5038 X(EXT_TEMP_WARNING, FLAG(18), ) \
5039 X(SUPPLY_OVERVOLTAGE_WARNING, FLAG(19), ) \
5040 X(SUPPLY_UNDERVOLTAGE_WARNING, FLAG(20), ) \
5041 X(ADC_IN_OVERVOLTAGE, FLAG(21), ) \
5042 X(FAULT_RETRY_HAPPENED, FLAG(22), ) \
5043 X(FAULT_RETRIES_FAILED, FLAG(23), ) \
5044 X(CHIP_TEMP_WARNING, FLAG(24), ) \
5045 X(HEARTBEAT_STOPPED, FLAG(26), )
5046
5047enum class GeneralErrorFlags : uint32_t {
5048 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5049 GENERAL_ERROR_FLAGS_LIST(X)
5050 #undef X
5051};
5052
5053inline const char* to_string(GeneralErrorFlags e) {
5054 switch(e) {
5055 #define X(NAME, VALUE, DOC) case GeneralErrorFlags::NAME: return #NAME;
5056 GENERAL_ERROR_FLAGS_LIST(X)
5057 #undef X
5058 default: return "UNKNOWN";
5059 }
5060}
5061#undef GENERAL_ERROR_FLAGS_LIST
5063
5066//--------------------------------------
5067// Gate Driver Error Flags
5068//--------------------------------------
5106#define GATE_DRIVER_ERROR_FLAGS_LIST(X) \
5107 X(U_LOW_SIDE_OVERCURRENT, FLAG(0), ) \
5108 X(V_LOW_SIDE_OVERCURRENT, FLAG(1), ) \
5109 X(W_LOW_SIDE_OVERCURRENT, FLAG(2), ) \
5110 X(Y2_LOW_SIDE_OVERCURRENT, FLAG(3), ) \
5111 X(U_LOW_SIDE_DISCHARGE_SHORT, FLAG(4), ) \
5112 X(V_LOW_SIDE_DISCHARGE_SHORT, FLAG(5), ) \
5113 X(W_LOW_SIDE_DISCHARGE_SHORT, FLAG(6), ) \
5114 X(Y2_LOW_SIDE_DISCHARGE_SHORT, FLAG(7), ) \
5115 X(U_LOW_SIDE_CHARGE_SHORT, FLAG(8), ) \
5116 X(V_LOW_SIDE_CHARGE_SHORT, FLAG(9), ) \
5117 X(W_LOW_SIDE_CHARGE_SHORT, FLAG(10), ) \
5118 X(Y2_LOW_SIDE_CHARGE_SHORT, FLAG(11), ) \
5119 X(U_BOOTSTRAP_UNDERVOLTAGE, FLAG(12), ) \
5120 X(V_BOOTSTRAP_UNDERVOLTAGE, FLAG(13), ) \
5121 X(W_BOOTSTRAP_UNDERVOLTAGE, FLAG(14), ) \
5122 X(Y2_BOOTSTRAP_UNDERVOLTAGE, FLAG(15), ) \
5123 X(U_HIGH_SIDE_OVERCURRENT, FLAG(16), ) \
5124 X(V_HIGH_SIDE_OVERCURRENT, FLAG(17), ) \
5125 X(W_HIGH_SIDE_OVERCURRENT, FLAG(18), ) \
5126 X(Y2_HIGH_SIDE_OVERCURRENT, FLAG(19), ) \
5127 X(U_HIGH_SIDE_DISCHARGE_SHORT, FLAG(20), ) \
5128 X(V_HIGH_SIDE_DISCHARGE_SHORT, FLAG(21), ) \
5129 X(W_HIGH_SIDE_DISCHARGE_SHORT, FLAG(22), ) \
5130 X(Y2_HIGH_SIDE_DISCHARGE_SHORT, FLAG(23), ) \
5131 X(U_HIGH_SIDE_CHARGE_SHORT, FLAG(24), ) \
5132 X(V_HIGH_SIDE_CHARGE_SHORT, FLAG(25), ) \
5133 X(W_HIGH_SIDE_CHARGE_SHORT, FLAG(26), ) \
5134 X(Y2_HIGH_SIDE_CHARGE_SHORT, FLAG(27), ) \
5135 X(GDRV_UNDERVOLTAGE, FLAG(29), ) \
5136 X(GDRV_LOW_VOLTAGE, FLAG(30), ) \
5137 X(GDRV_SUPPLY_UNDERVOLTAGE, FLAG(31), )
5138
5139enum class GateDriverErrorFlags : uint32_t {
5140 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5141 GATE_DRIVER_ERROR_FLAGS_LIST(X)
5142 #undef X
5143};
5144
5145inline const char* to_string(GateDriverErrorFlags e) {
5146 switch(e) {
5147 #define X(NAME, VALUE, DOC) case GateDriverErrorFlags::NAME: return #NAME;
5148 GATE_DRIVER_ERROR_FLAGS_LIST(X)
5149 #undef X
5150 default: return "UNKNOWN";
5151 }
5152}
5153#undef GATE_DRIVER_ERROR_FLAGS_LIST
5155
5159// ADC Status Flags
5160//--------------------------------------
5181#define ADC_STATUS_FLAGS_LIST(X) \
5182 X(I0_CLIPPED, 0x00000001, ) \
5183 X(I1_CLIPPED, 0x00000002, ) \
5184 X(I2_CLIPPED, 0x00000004, ) \
5185 X(I3_CLIPPED, 0x00000008, ) \
5186 X(U0_CLIPPED, 0x00000010, ) \
5187 X(U1_CLIPPED, 0x00000020, ) \
5188 X(U2_CLIPPED, 0x00000040, ) \
5189 X(U3_CLIPPED, 0x00000080, ) \
5190 X(AIN0_CLIPPED, 0x00000100, ) \
5191 X(AIN1_CLIPPED, 0x00000200, ) \
5192 X(AIN2_CLIPPED, 0x00000400, ) \
5193 X(AIN3_CLIPPED, 0x00000800, ) \
5194 X(VM_CLIPPED, 0x00001000, ) \
5195 X(TEMP_CLIPPED, 0x00002000, )
5196
5197enum class AdcStatusFlags : uint32_t {
5198 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5199 ADC_STATUS_FLAGS_LIST(X)
5200 #undef X
5201};
5202
5203inline const char* to_string(AdcStatusFlags e) {
5204 switch(e) {
5205 #define X(NAME, VALUE, DOC) case AdcStatusFlags::NAME: return #NAME;
5206 ADC_STATUS_FLAGS_LIST(X)
5207 #undef X
5208 default: return "UNKNOWN";
5209 }
5210}
5211#undef ADC_STATUS_FLAGS_LIST
5213
5215// //
5216// ██████╗ █████╗ ██████╗ █████╗ ███╗ ███╗███████╗ //
5217// ██╔══██╗██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔════╝ //
5218// ██████╔╝███████║██████╔╝███████║██╔████╔██║███████╗ //
5219// ██╔═══╝ ██╔══██║██╔══██╗██╔══██║██║╚██╔╝██║╚════██║ //
5220// ██║ ██║ ██║██║ ██║██║ ██║██║ ╚═╝ ██║███████║ //
5221// ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ //
5222// //
5223//==================================================================================================================//
5224// PARAMETERS //
5225//==================================================================================================================//
5227
5228enum class Parameters : uint16_t {
5229 #define X(NAME, VALUE, DOC) NAME = VALUE DOC,
5230
5231 // Gate driver - parameters and configurations
5232 GATE_DRIVER_LIST(X)
5233
5234 // Gate driver - Overcurrent protection settings
5235 OVERCURRENT_PROTECTION_LIST(X)
5236
5237 // Gate driver - Undervoltage (UVLO) protection settings
5238 UNDERVOLTAGE_PROTECTION_LIST(X)
5239
5240 // Gate driver - Gate-to-source (VGS) short-circuit protection settings
5241 VGS_SHORT_PROTECTION_LIST(X)
5242
5243 // Motor configuration and drive settings
5244 MOTOR_CONFIG_LIST(X)
5245
5246 // ADC configuration for motor current measurement
5247 ADC_CONFIG_LIST(X)
5248
5249 // Feedback sensors (ABN, Hall, SPI encoders)
5250 FEEDBACK_SENSOR_CONFIG_LIST(X)
5251
5252 // Torque & flux control loops
5253 TORQUE_FLUX_CONTROL_LIST(X)
5254
5255 // Velocity control & ramping
5256 VELOCITY_CONTROL_LIST(X)
5257
5258 // Position control & ramping
5259 POSITION_CONTROL_LIST(X)
5260
5261 // Ramper stop conditions & reference switch
5262 RAMPER_STOP_CONFIG_LIST(X)
5263
5264 // Biquad filter parameters
5265 BIQUAD_FILTER_LIST(X)
5266
5267 // Fault-handling / retry behavior
5268 FAULT_HANDLING_LIST(X)
5269
5270 // I²t monitoring
5271 IIT_MONITOR_LIST(X)
5272
5273 // Temperature protection
5274 TEMPERATURE_PROTECTION_LIST(X)
5275
5276 // Heartbeat monitoring
5277 HEARTBEAT_MONITORING_LIST(X)
5278
5279 // Brake chopper settings
5280 BRAKE_CHOPPER_LIST(X)
5281
5282 // Mechanical brake parameters
5283 MECHANICAL_BRAKE_LIST(X)
5284
5285 // Automatic homing / reference search
5286 REFERENCE_SEARCH_LIST(X)
5287
5288 // STEP/DIR interface
5289 STEP_DIR_LIST(X)
5290
5291 // Hibernation & wakeup
5292 HIBERNATION_WAKEUP_LIST(X)
5293
5294 // System status and supply monitoring
5295 SYSTEM_STATUS_SUPPLY_LIST(X)
5296
5297 // Internal measurement parameters
5298 INTERNAL_MEASUREMENT_LIST(X)
5299
5300 // Combined diagnostic values
5301 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
5302
5303 // Error flags and status monitoring
5304 ERRORS_AND_FLAGS_LIST(X)
5305
5306 #undef X
5307};
5308
5320inline const char* to_string(Parameters param) {
5321 uint16_t value = static_cast<uint16_t>(param);
5322
5323 // Use X-macro to generate if-else chain for all parameters
5324 #define X(NAME, VALUE, DOC) if (value == static_cast<uint16_t>(Parameters::NAME)) return #NAME;
5325 GATE_DRIVER_LIST(X)
5326 OVERCURRENT_PROTECTION_LIST(X)
5327 UNDERVOLTAGE_PROTECTION_LIST(X)
5328 VGS_SHORT_PROTECTION_LIST(X)
5329 MOTOR_CONFIG_LIST(X)
5330 ADC_CONFIG_LIST(X)
5331 FEEDBACK_SENSOR_CONFIG_LIST(X)
5332 TORQUE_FLUX_CONTROL_LIST(X)
5333 VELOCITY_CONTROL_LIST(X)
5334 POSITION_CONTROL_LIST(X)
5335 RAMPER_STOP_CONFIG_LIST(X)
5336 BIQUAD_FILTER_LIST(X)
5337 FAULT_HANDLING_LIST(X)
5338 IIT_MONITOR_LIST(X)
5339 TEMPERATURE_PROTECTION_LIST(X)
5340 HEARTBEAT_MONITORING_LIST(X)
5341 BRAKE_CHOPPER_LIST(X)
5342 MECHANICAL_BRAKE_LIST(X)
5343 REFERENCE_SEARCH_LIST(X)
5344 STEP_DIR_LIST(X)
5345 HIBERNATION_WAKEUP_LIST(X)
5346 SYSTEM_STATUS_SUPPLY_LIST(X)
5347 INTERNAL_MEASUREMENT_LIST(X)
5348 COMBINED_DIAGNOSTIC_VALUES_LIST(X)
5349 ERRORS_AND_FLAGS_LIST(X)
5350 #undef X
5351
5352 return "UNKNOWN_PARAM";
5353}
5354
5355/* ───────────── Clean-up (optional but tidy) ───────────── */
5356// Undefine all parameter-section X-macros to avoid polluting the global namespace.
5357#undef GATE_DRIVER_LIST
5358#undef OVERCURRENT_PROTECTION_LIST
5359#undef UNDERVOLTAGE_PROTECTION_LIST
5360#undef VGS_SHORT_PROTECTION_LIST
5361#undef MOTOR_CONFIG_LIST
5362#undef ADC_CONFIG_LIST
5363#undef FEEDBACK_SENSOR_CONFIG_LIST
5364#undef TORQUE_FLUX_CONTROL_LIST
5365#undef VELOCITY_CONTROL_LIST
5366#undef POSITION_CONTROL_LIST
5367#undef RAMPER_STOP_CONFIG_LIST
5368#undef BIQUAD_FILTER_LIST
5369#undef FAULT_HANDLING_LIST
5370#undef IIT_MONITOR_LIST
5371#undef TEMPERATURE_PROTECTION_LIST
5372#undef HEARTBEAT_MONITORING_LIST
5373#undef BRAKE_CHOPPER_LIST
5374#undef MECHANICAL_BRAKE_LIST
5375#undef REFERENCE_SEARCH_LIST
5376#undef STEP_DIR_LIST
5377#undef HIBERNATION_WAKEUP_LIST
5378#undef SYSTEM_STATUS_SUPPLY_LIST
5379#undef INTERNAL_MEASUREMENT_LIST
5380#undef COMBINED_DIAGNOSTIC_VALUES_LIST
5381#undef ERRORS_AND_FLAGS_LIST
5382#undef FLAG
5383
5384// clang-format on
5385} // namespace tmc9660::tmcl
tmc9660::tmcl
TMCL command interface namespace for TMC9660.
Definition tmc9660_param_mode_tmcl.hpp:45
tmc9660::tmcl::IitMonitor
IitMonitor
Definition tmc9660_param_mode_tmcl.hpp:3853
tmc9660::tmcl::UndervoltageEnable
UndervoltageEnable
Definition tmc9660_param_mode_tmcl.hpp:1313
tmc9660::tmcl::ReferenceSwitchEnable
ReferenceSwitchEnable
Definition tmc9660_param_mode_tmcl.hpp:3332
tmc9660::tmcl::CombinedDiagnosticValues
CombinedDiagnosticValues
Definition tmc9660_param_mode_tmcl.hpp:4810
tmc9660::tmcl::AbnInitState
AbnInitState
Definition tmc9660_param_mode_tmcl.hpp:2348
tmc9660::tmcl::ReferenceSearchCommand
ReferenceSearchCommand
Definition tmc9660_param_mode_tmcl.hpp:4335
tmc9660::tmcl::PwmFrequency
PwmFrequency
Definition tmc9660_param_mode_tmcl.hpp:2118
tmc9660::tmcl::WaitCondition
WaitCondition
Definition tmc9660_param_mode_tmcl.hpp:273
tmc9660::tmcl::GateCurrentSource
GateCurrentSource
Definition tmc9660_param_mode_tmcl.hpp:868
tmc9660::tmcl::GateCurrentSink
GateCurrentSink
Definition tmc9660_param_mode_tmcl.hpp:808
tmc9660::tmcl::OvercurrentTiming
OvercurrentTiming
Definition tmc9660_param_mode_tmcl.hpp:1135
tmc9660::tmcl::HeartbeatMonitoring
HeartbeatMonitoring
Definition tmc9660_param_mode_tmcl.hpp:3993
tmc9660::tmcl::RamDebugState
RamDebugState
Definition tmc9660_param_mode_tmcl.hpp:418
tmc9660::tmcl::EventStopSettings
EventStopSettings
Definition tmc9660_param_mode_tmcl.hpp:3505
tmc9660::tmcl::ReferenceSearchStatus
ReferenceSearchStatus
Definition tmc9660_param_mode_tmcl.hpp:4398
tmc9660::tmcl::ReferenceSearch
ReferenceSearch
Definition tmc9660_param_mode_tmcl.hpp:4246
tmc9660::tmcl::SystemStatusSupply
SystemStatusSupply
Definition tmc9660_param_mode_tmcl.hpp:4702
tmc9660::tmcl::AdcMapping
AdcMapping
Definition tmc9660_param_mode_tmcl.hpp:2048
tmc9660::tmcl::OvercurrentThreshold
OvercurrentThreshold
Definition tmc9660_param_mode_tmcl.hpp:1091
tmc9660::tmcl::VgsShortEnable
VgsShortEnable
Definition tmc9660_param_mode_tmcl.hpp:1396
tmc9660::tmcl::BrakeChopper
BrakeChopper
Definition tmc9660_param_mode_tmcl.hpp:4100
tmc9660::tmcl::to_string
const char * to_string(Op op)
Definition tmc9660_param_mode_tmcl.hpp:189
tmc9660::tmcl::FaultHandling
FaultHandling
Definition tmc9660_param_mode_tmcl.hpp:3695
tmc9660::tmcl::PowerDownTimeout
PowerDownTimeout
Definition tmc9660_param_mode_tmcl.hpp:4640
tmc9660::tmcl::CommutationMode
CommutationMode
Definition tmc9660_param_mode_tmcl.hpp:1765
tmc9660::tmcl::StepDirStepDividerShift
StepDirStepDividerShift
Definition tmc9660_param_mode_tmcl.hpp:4522
tmc9660::tmcl::BiquadFilterEnable
BiquadFilterEnable
Definition tmc9660_param_mode_tmcl.hpp:3633
tmc9660::tmcl::VelocityPiNorm
VelocityPiNorm
Definition tmc9660_param_mode_tmcl.hpp:2946
tmc9660::tmcl::MotorDirection
MotorDirection
Definition tmc9660_param_mode_tmcl.hpp:1612
tmc9660::tmcl::PositionControl
PositionControl
Definition tmc9660_param_mode_tmcl.hpp:3109
tmc9660::tmcl::VgsBlankingTime
VgsBlankingTime
Definition tmc9660_param_mode_tmcl.hpp:1432
tmc9660::tmcl::DriveFaultBehaviour
DriveFaultBehaviour
Definition tmc9660_param_mode_tmcl.hpp:3774
tmc9660::tmcl::Direction
Direction
Definition tmc9660_param_mode_tmcl.hpp:2558
tmc9660::tmcl::AdcStatusFlags
AdcStatusFlags
Definition tmc9660_param_mode_tmcl.hpp:5197
tmc9660::tmcl::RamperStopConfig
RamperStopConfig
Definition tmc9660_param_mode_tmcl.hpp:3280
tmc9660::tmcl::BootstrapCurrentLimit
BootstrapCurrentLimit
Definition tmc9660_param_mode_tmcl.hpp:912
tmc9660::tmcl::VdsUsage
VdsUsage
Definition tmc9660_param_mode_tmcl.hpp:1167
tmc9660::tmcl::GdrvRetryBehaviour
GdrvRetryBehaviour
Definition tmc9660_param_mode_tmcl.hpp:3735
tmc9660::tmcl::SpiEncoderTransfer
SpiEncoderTransfer
Definition tmc9660_param_mode_tmcl.hpp:2460
tmc9660::tmcl::GeneralStatusFlags
GeneralStatusFlags
Definition tmc9660_param_mode_tmcl.hpp:4979
tmc9660::tmcl::MechanicalBrake
MechanicalBrake
Definition tmc9660_param_mode_tmcl.hpp:4173
tmc9660::tmcl::CsaFilter
CsaFilter
Definition tmc9660_param_mode_tmcl.hpp:2012
tmc9660::tmcl::PwmSwitchingScheme
PwmSwitchingScheme
Definition tmc9660_param_mode_tmcl.hpp:1646
tmc9660::tmcl::EnableDisable
EnableDisable
Definition tmc9660_param_mode_tmcl.hpp:2526
tmc9660::tmcl::GateDriverErrorFlags
GateDriverErrorFlags
Definition tmc9660_param_mode_tmcl.hpp:5139
tmc9660::tmcl::VelocityControl
VelocityControl
Definition tmc9660_param_mode_tmcl.hpp:2861
tmc9660::tmcl::ReplyCode
ReplyCode
Definition tmc9660_param_mode_tmcl.hpp:321
tmc9660::tmcl::HibernationWakeup
HibernationWakeup
Definition tmc9660_param_mode_tmcl.hpp:4589
tmc9660::tmcl::ErrorsAndFlags
ErrorsAndFlags
Definition tmc9660_param_mode_tmcl.hpp:4874
tmc9660::tmcl::InternalMeasurement
InternalMeasurement
Definition tmc9660_param_mode_tmcl.hpp:4761
tmc9660::tmcl::VelocityMeterMode
VelocityMeterMode
Definition tmc9660_param_mode_tmcl.hpp:2983
tmc9660::tmcl::GeneralErrorFlags
GeneralErrorFlags
Definition tmc9660_param_mode_tmcl.hpp:5047
tmc9660::tmcl::AdcShuntType
AdcShuntType
Definition tmc9660_param_mode_tmcl.hpp:1938
tmc9660::tmcl::GateDriver
GateDriver
Definition tmc9660_param_mode_tmcl.hpp:711
tmc9660::tmcl::CurrentPiNormalization
CurrentPiNormalization
Definition tmc9660_param_mode_tmcl.hpp:2732
tmc9660::tmcl::ReferenceSwitchSearchMode
ReferenceSwitchSearchMode
Definition tmc9660_param_mode_tmcl.hpp:4298
tmc9660::tmcl::RamDebugType
RamDebugType
Definition tmc9660_param_mode_tmcl.hpp:379
tmc9660::tmcl::PwmOutputPolarity
PwmOutputPolarity
Definition tmc9660_param_mode_tmcl.hpp:748
tmc9660::tmcl::UndervoltageProtection
UndervoltageProtection
Definition tmc9660_param_mode_tmcl.hpp:1212
tmc9660::tmcl::TorqueFluxControl
TorqueFluxControl
Definition tmc9660_param_mode_tmcl.hpp:2657
tmc9660::tmcl::PositionPiNorm
PositionPiNorm
Definition tmc9660_param_mode_tmcl.hpp:3194
tmc9660::tmcl::FeedbackSensorConfig
FeedbackSensorConfig
Definition tmc9660_param_mode_tmcl.hpp:2271
tmc9660::tmcl::SpiInitMethod
SpiInitMethod
Definition tmc9660_param_mode_tmcl.hpp:2494
tmc9660::tmcl::AdcInversion
AdcInversion
Definition tmc9660_param_mode_tmcl.hpp:2080
tmc9660::tmcl::Op
Op
Definition tmc9660_param_mode_tmcl.hpp:183
tmc9660::tmcl::Op::X
X(NAME, VALUE, DOC)
tmc9660::tmcl::GlobalParamBank3
GlobalParamBank3
Definition tmc9660_param_mode_tmcl.hpp:568
tmc9660::tmcl::GlobalParamBank0
GlobalParamBank0
Definition tmc9660_param_mode_tmcl.hpp:479
tmc9660::tmcl::TorqueFluxPiSeparation
TorqueFluxPiSeparation
Definition tmc9660_param_mode_tmcl.hpp:2697
tmc9660::tmcl::OvercurrentEnable
OvercurrentEnable
Definition tmc9660_param_mode_tmcl.hpp:1022
tmc9660::tmcl::BiquadFilter
BiquadFilter
Definition tmc9660_param_mode_tmcl.hpp:3593
tmc9660::tmcl::MotorConfig
MotorConfig
Definition tmc9660_param_mode_tmcl.hpp:1539
tmc9660::tmcl::CalcOperation
CalcOperation
Definition tmc9660_param_mode_tmcl.hpp:214
tmc9660::tmcl::Parameters
Parameters
Definition tmc9660_param_mode_tmcl.hpp:5228
tmc9660::tmcl::ReferenceSwitchPolaritySwap
ReferenceSwitchPolaritySwap
Definition tmc9660_param_mode_tmcl.hpp:3395
tmc9660::tmcl::CsaGain
CsaGain
Definition tmc9660_param_mode_tmcl.hpp:1976
tmc9660::tmcl::StepDir
StepDir
Definition tmc9660_param_mode_tmcl.hpp:4463
tmc9660::tmcl::VelocitySensorSelection
VelocitySensorSelection
Definition tmc9660_param_mode_tmcl.hpp:2907
tmc9660::tmcl::MotorType
MotorType
Definition tmc9660_param_mode_tmcl.hpp:1580
tmc9660::tmcl::VgsDeglitchTime
VgsDeglitchTime
Definition tmc9660_param_mode_tmcl.hpp:1476
tmc9660::tmcl::VgsShortProtection
VgsShortProtection
Definition tmc9660_param_mode_tmcl.hpp:1359
tmc9660::tmcl::HeartbeatMonitoringConfig
HeartbeatMonitoringConfig
Definition tmc9660_param_mode_tmcl.hpp:4037
tmc9660::tmcl::ReferenceSwitchLatchSettings
ReferenceSwitchLatchSettings
Definition tmc9660_param_mode_tmcl.hpp:3458
tmc9660::tmcl::AbnNChannelFiltering
AbnNChannelFiltering
Definition tmc9660_param_mode_tmcl.hpp:2386
tmc9660::tmcl::HallSectorOffset
HallSectorOffset
Definition tmc9660_param_mode_tmcl.hpp:2426
tmc9660::tmcl::PositionSensorSelection
PositionSensorSelection
Definition tmc9660_param_mode_tmcl.hpp:3155
tmc9660::tmcl::OvercurrentProtection
OvercurrentProtection
Definition tmc9660_param_mode_tmcl.hpp:985
tmc9660::tmcl::UndervoltageLevel
UndervoltageLevel
Definition tmc9660_param_mode_tmcl.hpp:1281
tmc9660::tmcl::TriggerTransition
TriggerTransition
Definition tmc9660_param_mode_tmcl.hpp:611
tmc9660::tmcl::AbnInitMethod
AbnInitMethod
Definition tmc9660_param_mode_tmcl.hpp:2312
tmc9660::tmcl::TemperatureProtection
TemperatureProtection
Definition tmc9660_param_mode_tmcl.hpp:3928
tmc9660::tmcl::AdcConfig
AdcConfig
Definition tmc9660_param_mode_tmcl.hpp:1895
tmc9660::tmcl::GlobalParamBank2
GlobalParamBank2
Definition tmc9660_param_mode_tmcl.hpp:519
tmc9660::tmcl::AccelerationFFShift
AccelerationFFShift
Definition tmc9660_param_mode_tmcl.hpp:3028
tmc9660::tmcl::IdleMotorPwmBehavior
IdleMotorPwmBehavior
Definition tmc9660_param_mode_tmcl.hpp:1800
tmc9660::tmcl::JumpCondition
JumpCondition
Definition tmc9660_param_mode_tmcl.hpp:244
HALL_SECTOR_OFFSET_LIST
#define HALL_SECTOR_OFFSET_LIST(X)
Enumerates Hall sector offsets.
Definition tmc9660_param_mode_tmcl.hpp:2418
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:850
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:1754
GLOBAL_PARAM_BANK2_LIST
#define GLOBAL_PARAM_BANK2_LIST(X)
User-script variables 0…15. RWE.
Definition tmc9660_param_mode_tmcl.hpp:501
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:3271
FAULT_HANDLING_LIST
#define FAULT_HANDLING_LIST(X)
Parameters for configuring system behavior on fault conditions.
Definition tmc9660_param_mode_tmcl.hpp:3690
VGS_DEGLITCH_TIME_LIST
#define VGS_DEGLITCH_TIME_LIST(X)
Enumerates possible deglitch times for VGS short protection.
Definition tmc9660_param_mode_tmcl.hpp:1466
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:4509
ABN_INIT_METHOD_LIST
#define ABN_INIT_METHOD_LIST(X)
Enumerates ABN encoder initialization methods.
Definition tmc9660_param_mode_tmcl.hpp:2306
MOTOR_DIRECTION_LIST
#define MOTOR_DIRECTION_LIST(X)
Enumerates motor rotation directions.
Definition tmc9660_param_mode_tmcl.hpp:1608
INTERNAL_MEASUREMENT_LIST
#define INTERNAL_MEASUREMENT_LIST(X)
Raw diagnostic values and FOC internal measurements.
Definition tmc9660_param_mode_tmcl.hpp:4749
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:1345
REFERENCE_SEARCH_MODE_LIST
#define REFERENCE_SEARCH_MODE_LIST(X)
Enumerates reference search (homing) patterns.
Definition tmc9660_param_mode_tmcl.hpp:4288
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:605
SPI_INIT_METHOD_LIST
#define SPI_INIT_METHOD_LIST(X)
Enumerates SPI encoder initialization methods.
Definition tmc9660_param_mode_tmcl.hpp:2489
OVERCURRENT_TIMING_LIST
#define OVERCURRENT_TIMING_LIST(X)
Enumerates possible blanking and deglitch times for overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1125
POSITION_SENSOR_SELECTION_LIST
#define POSITION_SENSOR_SELECTION_LIST(X)
Enumerates feedback sources for position PI regulator.
Definition tmc9660_param_mode_tmcl.hpp:3148
PWM_FREQUENCY_LIST
#define PWM_FREQUENCY_LIST(X)
Enumerates recommended PWM frequencies for different motor types.
Definition tmc9660_param_mode_tmcl.hpp:2111
ABN_N_CHANNEL_FILTERING_LIST
#define ABN_N_CHANNEL_FILTERING_LIST(X)
Enumerates ABN N-channel filtering modes.
Definition tmc9660_param_mode_tmcl.hpp:2379
GDRV_RETRY_BEHAVIOUR_LIST
#define GDRV_RETRY_BEHAVIOUR_LIST(X)
System state after a gate driver fault occurs.
Definition tmc9660_param_mode_tmcl.hpp:3731
IIT_MONITOR_LIST
#define IIT_MONITOR_LIST(X)
Parameters for configuring IIT (I²t) monitoring and protection.
Definition tmc9660_param_mode_tmcl.hpp:3843
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:463
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:2693
VELOCITY_PI_NORM_LIST
#define VELOCITY_PI_NORM_LIST(X)
Enumerates normalization formats for velocity PI controller.
Definition tmc9660_param_mode_tmcl.hpp:2940
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:3768
ADC_SHUNT_TYPE_LIST
#define ADC_SHUNT_TYPE_LIST(X)
Enumerates shunt types for ADC measurements.
Definition tmc9660_param_mode_tmcl.hpp:1931
DIRECTION_LIST
#define DIRECTION_LIST(X)
Direction settings used by various encoder parameters.
Definition tmc9660_param_mode_tmcl.hpp:2554
OP_LIST
#define OP_LIST(X)
Operation codes accepted by the TMC9660 Parameter Mode (Table 18).
Definition tmc9660_param_mode_tmcl.hpp:131
POSITION_PI_NORM_LIST
#define POSITION_PI_NORM_LIST(X)
Enumerates normalization formats for position PI controller.
Definition tmc9660_param_mode_tmcl.hpp:3188
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:4946
SYSTEM_STATUS_SUPPLY_LIST
#define SYSTEM_STATUS_SUPPLY_LIST(X)
Parameters for supply voltage warnings.
Definition tmc9660_param_mode_tmcl.hpp:4697
POWER_DOWN_TIMEOUT_LIST
#define POWER_DOWN_TIMEOUT_LIST(X)
Enumerates timeout durations for power-down state.
Definition tmc9660_param_mode_tmcl.hpp:4630
ERRORS_AND_FLAGS_LIST
#define ERRORS_AND_FLAGS_LIST(X)
Parameters for temperature monitoring and error flags.
Definition tmc9660_param_mode_tmcl.hpp:4867
VELOCITY_SENSOR_SELECTION_LIST
#define VELOCITY_SENSOR_SELECTION_LIST(X)
Enumerates feedback sources for velocity PI regulator.
Definition tmc9660_param_mode_tmcl.hpp:2900
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:1796
COMBINED_DIAGNOSTIC_VALUES_LIST
#define COMBINED_DIAGNOSTIC_VALUES_LIST(X)
Simplified combined measurement registers used during tuning.
Definition tmc9660_param_mode_tmcl.hpp:4803
OVERCURRENT_THRESHOLD_LIST
#define OVERCURRENT_THRESHOLD_LIST(X)
Enumerates possible threshold values for overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1073
REFERENCE_SEARCH_STATUS_LIST
#define REFERENCE_SEARCH_STATUS_LIST(X)
Enumerates status codes for reference search state machine.
Definition tmc9660_param_mode_tmcl.hpp:4380
ADC_CONFIG_LIST
#define ADC_CONFIG_LIST(X)
Parameters for configuring ADCs for motor current measurement.
Definition tmc9660_param_mode_tmcl.hpp:1863
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:1392
HIBERNATION_WAKEUP_LIST
#define HIBERNATION_WAKEUP_LIST(X)
Parameters for configuring hibernation (low-power) and wakeup behavior.
Definition tmc9660_param_mode_tmcl.hpp:4585
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:3440
ENABLE_DISABLE_LIST
#define ENABLE_DISABLE_LIST(X)
Generic enable/disable settings used by various parameters.
Definition tmc9660_param_mode_tmcl.hpp:2522
TORQUE_FLUX_CONTROL_LIST
#define TORQUE_FLUX_CONTROL_LIST(X)
Parameters for configuring torque and flux control loops.
Definition tmc9660_param_mode_tmcl.hpp:2634
UNDERVOLTAGE_LEVEL_LIST
#define UNDERVOLTAGE_LEVEL_LIST(X)
Enumerates possible levels for undervoltage protection.
Definition tmc9660_param_mode_tmcl.hpp:1262
PWM_OUTPUT_POLARITY_LIST
#define PWM_OUTPUT_POLARITY_LIST(X)
Table — PWM Output Polarity:
Definition tmc9660_param_mode_tmcl.hpp:744
BRAKE_CHOPPER_LIST
#define BRAKE_CHOPPER_LIST(X)
Parameters for configuring the brake chopper functionality.
Definition tmc9660_param_mode_tmcl.hpp:4095
MOTOR_TYPE_LIST
#define MOTOR_TYPE_LIST(X)
Enumerates supported motor types.
Definition tmc9660_param_mode_tmcl.hpp:1574
ACCELERATION_FF_SHIFT_LIST
#define ACCELERATION_FF_SHIFT_LIST(X)
Enumerates shift values for acceleration feedforward.
Definition tmc9660_param_mode_tmcl.hpp:3019
CSA_GAIN_LIST
#define CSA_GAIN_LIST(X)
Enumerates current sense amplifier gain settings.
Definition tmc9660_param_mode_tmcl.hpp:1969
HEARTBEAT_MONITORING_LIST
#define HEARTBEAT_MONITORING_LIST(X)
Parameters for configuring heartbeat monitoring.
Definition tmc9660_param_mode_tmcl.hpp:3989
OVERCURRENT_PROTECTION_LIST
#define OVERCURRENT_PROTECTION_LIST(X)
Parameters for configuring gate driver overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:965
EVENT_STOP_SETTINGS_LIST
#define EVENT_STOP_SETTINGS_LIST(X)
Bitwise configuration for stop conditions.
Definition tmc9660_param_mode_tmcl.hpp:3495
ADC_INVERSION_LIST
#define ADC_INVERSION_LIST(X)
Enumerates ADC inversion settings.
Definition tmc9660_param_mode_tmcl.hpp:2076
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:902
MOTOR_CONFIG_LIST
#define MOTOR_CONFIG_LIST(X)
Parameters for configuring motor characteristics and drive settings.
Definition tmc9660_param_mode_tmcl.hpp:1529
TEMPERATURE_PROTECTION_LIST
#define TEMPERATURE_PROTECTION_LIST(X)
Parameters for configuring temperature protection using external and internal sensors.
Definition tmc9660_param_mode_tmcl.hpp:3920
RAMDEBUG_STATE_LIST
#define RAMDEBUG_STATE_LIST(X)
Values returned by ::RamDebugType::GET_STATE.
Definition tmc9660_param_mode_tmcl.hpp:411
UNDERVOLTAGE_PROTECTION_LIST
#define UNDERVOLTAGE_PROTECTION_LIST(X)
Parameters for configuring undervoltage lockout (UVLO) protection.
Definition tmc9660_param_mode_tmcl.hpp:1206
WAIT_CONDITION_LIST
#define WAIT_CONDITION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:263
GATE_DRIVER_LIST
#define GATE_DRIVER_LIST(X)
Parameters for gate driver timer and current settings (Table 20).
Definition tmc9660_param_mode_tmcl.hpp:692
HEARTBEAT_MONITORING_CONFIG_LIST
#define HEARTBEAT_MONITORING_CONFIG_LIST(X)
Enumerates heartbeat monitoring interface selection.
Definition tmc9660_param_mode_tmcl.hpp:4031
MECHANICAL_BRAKE_LIST
#define MECHANICAL_BRAKE_LIST(X)
Parameters for controlling an external mechanical brake.
Definition tmc9660_param_mode_tmcl.hpp:4166
JUMP_CONDITION_LIST
#define JUMP_CONDITION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:233
PWM_SWITCHING_SCHEME_LIST
#define PWM_SWITCHING_SCHEME_LIST(X)
Enumerates PWM switching schemes.
Definition tmc9660_param_mode_tmcl.hpp:1641
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:3377
ABN_INIT_STATE_LIST
#define ABN_INIT_STATE_LIST(X)
Enumerates ABN encoder initialization states.
Definition tmc9660_param_mode_tmcl.hpp:2342
GENERAL_ERROR_FLAGS_LIST
#define GENERAL_ERROR_FLAGS_LIST(X)
Enumerates general error flags for GENERAL_ERROR_FLAGS.
Definition tmc9660_param_mode_tmcl.hpp:5028
CURRENT_PI_NORMALIZATION_LIST
#define CURRENT_PI_NORMALIZATION_LIST(X)
Normalization format for current PI controller output.
Definition tmc9660_param_mode_tmcl.hpp:2728
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:541
OVERCURRENT_ENABLE_LIST
#define OVERCURRENT_ENABLE_LIST(X)
Enumerates options for enabling or disabling overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1018
CALC_OPERATION_LIST
#define CALC_OPERATION_LIST(X)
Definition tmc9660_param_mode_tmcl.hpp:202
RAMDEBUG_TYPE_LIST
#define RAMDEBUG_TYPE_LIST(X)
TYPE field values when Operation::RamDebug is issued.
Definition tmc9660_param_mode_tmcl.hpp:363
ADC_STATUS_FLAGS_LIST
#define ADC_STATUS_FLAGS_LIST(X)
Bit flags reported via parameter ADC_STATUS_FLAGS.
Definition tmc9660_param_mode_tmcl.hpp:5181
VGS_BLANKING_TIME_LIST
#define VGS_BLANKING_TIME_LIST(X)
Enumerates possible blanking times for VGS short protection.
Definition tmc9660_param_mode_tmcl.hpp:1426
BIQUAD_FILTER_ENABLE_LIST
#define BIQUAD_FILTER_ENABLE_LIST(X)
Enumerates enable/disable options for biquad filters.
Definition tmc9660_param_mode_tmcl.hpp:3629
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:790
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:3579
VDS_USAGE_LIST
#define VDS_USAGE_LIST(X)
Enumerates options for VDS measurement usage in overcurrent protection.
Definition tmc9660_param_mode_tmcl.hpp:1163
REFERENCE_SEARCH_LIST
#define REFERENCE_SEARCH_LIST(X)
Parameters for configuring automatic homing/reference search routines.
Definition tmc9660_param_mode_tmcl.hpp:4238
SPI_ENCODER_TRANSFER_LIST
#define SPI_ENCODER_TRANSFER_LIST(X)
Enumerates SPI encoder transfer modes.
Definition tmc9660_param_mode_tmcl.hpp:2455
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:3322
UNDERVOLTAGE_ENABLE_LIST
#define UNDERVOLTAGE_ENABLE_LIST(X)
Enumerates options for enabling or disabling undervoltage protection.
Definition tmc9660_param_mode_tmcl.hpp:1309
POSITION_CONTROL_LIST
#define POSITION_CONTROL_LIST(X)
Parameters for configuring position control and ramping.
Definition tmc9660_param_mode_tmcl.hpp:3092
ADC_MAPPING_LIST
#define ADC_MAPPING_LIST(X)
Enumerates ADC mapping options for motor phases.
Definition tmc9660_param_mode_tmcl.hpp:2042
VELOCITY_CONTROL_LIST
#define VELOCITY_CONTROL_LIST(X)
Parameters for configuring velocity control and ramping.
Definition tmc9660_param_mode_tmcl.hpp:2820
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:5106
CSA_FILTER_LIST
#define CSA_FILTER_LIST(X)
Enumerates current sense amplifier filter settings.
Definition tmc9660_param_mode_tmcl.hpp:2006
VELOCITY_METER_MODE_LIST
#define VELOCITY_METER_MODE_LIST(X)
Enumerates velocity meter modes.
Definition tmc9660_param_mode_tmcl.hpp:2978
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:2220
STEP_DIR_LIST
#define STEP_DIR_LIST(X)
Parameters for configuring the STEP/DIR target movement interface.
Definition tmc9660_param_mode_tmcl.hpp:4455
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:309
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:4330