Mirrors_Framework/g2
1
0
Fork 0
mirror of https://github.com/synthetos/g2.git synced 2026-09-22 03:08:42 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Intermediate commit - changing canonical machine struct to work by pointer - not absolute. Compiles. Does not run.

Browse Source
This commit is contained in:
Alden Hart
2016-12-09 07:41:31 -05:00
parent 58a615358f
commit a4330f42cc
20 changed files with 704 additions and 680 deletions
Download Patch File Download Diff File Expand all files Collapse all files
g2core/canonical_machine.cpp
+270 -250
View File
File diff suppressed because it is too large Load Diff
g2core/canonical_machine.h
+15 -12
View File
@@ -37,12 +37,12 @@
/* Defines, Macros, and Assorted Parameters */
#define MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model
#define MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model
#define PLANNER (GCodeState_t *)&bf->gm // relative to buffer *bf is currently pointing to
#define RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct
#define ACTIVE_MODEL cm.am // active model pointer is maintained by state management
#define ACTIVE_MODEL cm->am // active model pointer is maintained by state management
#define _to_millimeters(a) ((cm.gm.units_mode == INCHES) ? (a * MM_PER_INCH) : a)
#define _to_millimeters(a) ((cm->gm.units_mode == INCHES) ? (a * MM_PER_INCH) : a)
#define JOGGING_START_VELOCITY ((float)10.0)
#define DISABLE_SOFT_LIMIT (999999)
@@ -53,9 +53,9 @@
* MACHINE STATE MODEL
*
* The following main variables track canonical machine state and state transitions.
* - cm.machine_state - overall state of machine and program execution
* - cm.cycle_state - what cycle the machine is executing (or none)
* - cm.motion_state - state of movement
* - cm->machine_state - overall state of machine and program execution
* - cm->cycle_state - what cycle the machine is executing (or none)
* - cm->motion_state - state of movement
*/
// *** Note: check config printout strings align with all the state variables
@@ -128,15 +128,15 @@ typedef enum { // queue flush state machine
FLUSH_REQUESTED, // flush has been requested but not started yet
} cmQueueFlushState;
typedef enum { // applies to cm.homing_state
typedef enum { // applies to cm->homing_state
HOMING_NOT_HOMED = 0, // machine is not homed (0=false)
HOMING_HOMED = 1, // machine is homed (1=true)
HOMING_WAITING // machine waiting to be homed
} cmHomingState;
typedef enum { // applies to cm.probe_state
typedef enum { // applies to cm->probe_state
PROBE_FAILED = 0, // probe reached endpoint without triggering
PROBE_SUCCEEDED = 1, // probe was triggered, cm.probe_results has position
PROBE_SUCCEEDED = 1, // probe was triggered, cm->probe_results has position
PROBE_WAITING // probe is waiting to be started
} cmProbeState;
@@ -308,7 +308,7 @@ typedef enum { // axis modes (ordered: see _cm_get_feed_time())
* some state elements are necessarily restored from gm.
*
* - gf is used by the gcode parser interpreter to hold flags for any data
* that has changed in gn during the parse. cm.gf.target[] values are also used
* that has changed in gn during the parse. cm->gf.target[] values are also used
* by the canonical machine during set_target().
*
* - cfg (config struct in config.h) is also used heavily and contains some
@@ -580,9 +580,12 @@ typedef struct cmSingleton { // struct to manage cm globals and c
magic_t magic_end;
} cmMachine_t;
/**** Externs - See canonical_machine.c for allocation ****/
/**** Externs - See canonical_machine.cpp for allocation ****/
extern cmMachine_t cm; // canonical machine controller singleton
//extern cmMachine_t cm; // canonical machine controller singleton
extern cmMachine_t *cm; // pointer to active canonical machine
extern cmMachine_t cm0; // canonical machine primary machine
extern cmMachine_t cm1; // canonical machine secondary machine
/*****************************************************************************
* FUNCTION PROTOTYPES
g2core/config_app.cpp
+173 -173
View File
@@ -113,8 +113,8 @@ const cfgItem_t cfgArray[] = {
// dynamic model attributes for reporting purposes (up front for speed)
{ "", "stat",_f0, 0, cm_print_stat, cm_get_stat, set_nul,(float *)&cs.null, 0 }, // combined machine state
{ "", "n", _fi, 0, cm_print_line, cm_get_mline,set_int,(float *)&cm.gm.linenum,0 }, // Model line number
{ "", "line",_fi, 0, cm_print_line, cm_get_line, set_int,(float *)&cm.gm.linenum,0 }, // Active line number - model or runtime line number
{ "", "n", _fi, 0, cm_print_line, cm_get_mline,set_int,(float *)&cm->gm.linenum,0 }, // Model line number
{ "", "line",_fi, 0, cm_print_line, cm_get_line, set_int,(float *)&cm->gm.linenum,0 }, // Active line number - model or runtime line number
{ "", "vel", _f0, 2, cm_print_vel, cm_get_vel, set_nul,(float *)&cs.null, 0 }, // current velocity
{ "", "feed",_f0, 2, cm_print_feed, cm_get_feed, set_nul,(float *)&cs.null, 0 }, // feed rate
{ "", "macs",_f0, 0, cm_print_macs, cm_get_macs, set_nul,(float *)&cs.null, 0 }, // raw machine state
@@ -130,7 +130,7 @@ const cfgItem_t cfgArray[] = {
{ "", "admo",_f0, 0, cm_print_admo, cm_get_admo, set_nul,(float *)&cs.null, 0 }, // arc distance mode
{ "", "frmo",_f0, 0, cm_print_frmo, cm_get_frmo, set_nul,(float *)&cs.null, 0 }, // feed rate mode
{ "", "tool",_f0, 0, cm_print_tool, cm_get_toolv,set_nul,(float *)&cs.null, 0 }, // active tool
{ "", "g92e",_f0, 0, cm_print_g92e, get_ui8, set_nul,(float *)&cm.gmx.origin_offset_enable, 0 }, // G92 enabled
{ "", "g92e",_f0, 0, cm_print_g92e, get_ui8, set_nul,(float *)&cm->gmx.origin_offset_enable, 0 }, // G92 enabled
#ifdef TEMPORARY_HAS_LEDS
{ "", "_leds",_f0, 0, tx_print_nul, _get_leds,_set_leds,(float *)&cs.null, 0 }, // TEMPORARY - change LEDs
@@ -157,28 +157,28 @@ const cfgItem_t cfgArray[] = {
{ "ofs","ofsb",_f0, 3, cm_print_ofs, cm_get_ofs, set_nul,(float *)&cs.null, 0 }, // B work offset
{ "ofs","ofsc",_f0, 3, cm_print_ofs, cm_get_ofs, set_nul,(float *)&cs.null, 0 }, // C work offset
{ "hom","home",_f0, 0, cm_print_home,cm_get_home,set_01,(float *)&cm.homing_state, 0 }, // homing state, invoke homing cycle
{ "hom","homx",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_X], false }, // X homed - Homing status group
{ "hom","homy",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_Y], false }, // Y homed
{ "hom","homz",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_Z], false }, // Z homed
{ "hom","homa",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_A], false }, // A homed
{ "hom","homb",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_B], false }, // B homed
{ "hom","homc",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm.homed[AXIS_C], false }, // C homed
{ "hom","home",_f0, 0, cm_print_home,cm_get_home,set_01,(float *)&cm->homing_state, 0 }, // homing state, invoke homing cycle
{ "hom","homx",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_X], false }, // X homed - Homing status group
{ "hom","homy",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_Y], false }, // Y homed
{ "hom","homz",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_Z], false }, // Z homed
{ "hom","homa",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_A], false }, // A homed
{ "hom","homb",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_B], false }, // B homed
{ "hom","homc",_f0, 0, cm_print_hom, get_ui8, set_01, (float *)&cm->homed[AXIS_C], false }, // C homed
{ "prb","prbe",_f0, 0, tx_print_nul, get_ui8, set_nul,(float *)&cm.probe_state[0], 0 }, // probing state
{ "prb","prbx",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_X], 0 },
{ "prb","prby",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_Y], 0 },
{ "prb","prbz",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_Z], 0 },
{ "prb","prba",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_A], 0 },
{ "prb","prbb",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_B], 0 },
{ "prb","prbc",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm.probe_results[0][AXIS_C], 0 },
{ "prb","prbe",_f0, 0, tx_print_nul, get_ui8, set_nul,(float *)&cm->probe_state[0], 0 }, // probing state
{ "prb","prbx",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_X], 0 },
{ "prb","prby",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_Y], 0 },
{ "prb","prbz",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_Z], 0 },
{ "prb","prba",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_A], 0 },
{ "prb","prbb",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_B], 0 },
{ "prb","prbc",_f0, 3, tx_print_nul, get_flt, set_nul,(float *)&cm->probe_results[0][AXIS_C], 0 },
{ "jog","jogx",_f0, 0, tx_print_nul, get_nul, cm_run_jogx, (float *)&cm.jogging_dest, 0},
{ "jog","jogy",_f0, 0, tx_print_nul, get_nul, cm_run_jogy, (float *)&cm.jogging_dest, 0},
{ "jog","jogz",_f0, 0, tx_print_nul, get_nul, cm_run_jogz, (float *)&cm.jogging_dest, 0},
{ "jog","joga",_f0, 0, tx_print_nul, get_nul, cm_run_joga, (float *)&cm.jogging_dest, 0},
// { "jog","jogb",_f0, 0, tx_print_nul, get_nul, cm_run_jogb, (float *)&cm.jogging_dest, 0},
// { "jog","jogc",_f0, 0, tx_print_nul, get_nul, cm_run_jogc, (float *)&cm.jogging_dest, 0},
{ "jog","jogx",_f0, 0, tx_print_nul, get_nul, cm_run_jogx, (float *)&cm->jogging_dest, 0},
{ "jog","jogy",_f0, 0, tx_print_nul, get_nul, cm_run_jogy, (float *)&cm->jogging_dest, 0},
{ "jog","jogz",_f0, 0, tx_print_nul, get_nul, cm_run_jogz, (float *)&cm->jogging_dest, 0},
{ "jog","joga",_f0, 0, tx_print_nul, get_nul, cm_run_joga, (float *)&cm->jogging_dest, 0},
// { "jog","jogb",_f0, 0, tx_print_nul, get_nul, cm_run_jogb, (float *)&cm->jogging_dest, 0},
// { "jog","jogc",_f0, 0, tx_print_nul, get_nul, cm_run_jogc, (float *)&cm->jogging_dest, 0},
{ "pwr","pwr1",_f0, 3, st_print_pwr, st_get_pwr, set_nul, (float *)&cs.null, 0}, // motor power readouts
{ "pwr","pwr2",_f0, 3, st_print_pwr, st_get_pwr, set_nul, (float *)&cs.null, 0},
@@ -267,92 +267,92 @@ const cfgItem_t cfgArray[] = {
// { "6","6mt",_fip, 2, st_print_mt, get_flt, st_set_mt, (float *)&st_cfg.mot[MOTOR_6].motor_timeout, M6_MOTOR_TIMEOUT },
#endif
// Axis parameters
{ "x","xam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_X].axis_mode, X_AXIS_MODE },
{ "x","xvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_X].velocity_max, X_VELOCITY_MAX },
{ "x","xfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_X].feedrate_max, X_FEEDRATE_MAX },
{ "x","xtn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm.a[AXIS_X].travel_min, X_TRAVEL_MIN },
{ "x","xtm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm.a[AXIS_X].travel_max, X_TRAVEL_MAX },
{ "x","xjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_X].jerk_max, X_JERK_MAX },
{ "x","xjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_X].jerk_high, X_JERK_HIGH_SPEED },
{ "x","xhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_X].homing_input, X_HOMING_INPUT },
{ "x","xhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_X].homing_dir, X_HOMING_DIRECTION },
{ "x","xsv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm.a[AXIS_X].search_velocity,X_SEARCH_VELOCITY },
{ "x","xlv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm.a[AXIS_X].latch_velocity, X_LATCH_VELOCITY },
{ "x","xlb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm.a[AXIS_X].latch_backoff, X_LATCH_BACKOFF },
{ "x","xzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm.a[AXIS_X].zero_backoff, X_ZERO_BACKOFF },
{ "x","xam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_X].axis_mode, X_AXIS_MODE },
{ "x","xvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_X].velocity_max, X_VELOCITY_MAX },
{ "x","xfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_X].feedrate_max, X_FEEDRATE_MAX },
{ "x","xtn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm->a[AXIS_X].travel_min, X_TRAVEL_MIN },
{ "x","xtm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm->a[AXIS_X].travel_max, X_TRAVEL_MAX },
{ "x","xjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_X].jerk_max, X_JERK_MAX },
{ "x","xjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_X].jerk_high, X_JERK_HIGH_SPEED },
{ "x","xhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_X].homing_input, X_HOMING_INPUT },
{ "x","xhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_X].homing_dir, X_HOMING_DIRECTION },
{ "x","xsv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm->a[AXIS_X].search_velocity,X_SEARCH_VELOCITY },
{ "x","xlv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm->a[AXIS_X].latch_velocity, X_LATCH_VELOCITY },
{ "x","xlb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm->a[AXIS_X].latch_backoff, X_LATCH_BACKOFF },
{ "x","xzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm->a[AXIS_X].zero_backoff, X_ZERO_BACKOFF },
{ "y","yam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_Y].axis_mode, Y_AXIS_MODE },
{ "y","yvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_Y].velocity_max, Y_VELOCITY_MAX },
{ "y","yfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_Y].feedrate_max, Y_FEEDRATE_MAX },
{ "y","ytn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm.a[AXIS_Y].travel_min, Y_TRAVEL_MIN },
{ "y","ytm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm.a[AXIS_Y].travel_max, Y_TRAVEL_MAX },
{ "y","yjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_Y].jerk_max, Y_JERK_MAX },
{ "y","yjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_Y].jerk_high, Y_JERK_HIGH_SPEED },
{ "y","yhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_Y].homing_input, Y_HOMING_INPUT },
{ "y","yhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_Y].homing_dir, Y_HOMING_DIRECTION },
{ "y","ysv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm.a[AXIS_Y].search_velocity,Y_SEARCH_VELOCITY },
{ "y","ylv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm.a[AXIS_Y].latch_velocity, Y_LATCH_VELOCITY },
{ "y","ylb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm.a[AXIS_Y].latch_backoff, Y_LATCH_BACKOFF },
{ "y","yzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm.a[AXIS_Y].zero_backoff, Y_ZERO_BACKOFF },
{ "y","yam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_Y].axis_mode, Y_AXIS_MODE },
{ "y","yvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_Y].velocity_max, Y_VELOCITY_MAX },
{ "y","yfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_Y].feedrate_max, Y_FEEDRATE_MAX },
{ "y","ytn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm->a[AXIS_Y].travel_min, Y_TRAVEL_MIN },
{ "y","ytm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm->a[AXIS_Y].travel_max, Y_TRAVEL_MAX },
{ "y","yjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_Y].jerk_max, Y_JERK_MAX },
{ "y","yjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_Y].jerk_high, Y_JERK_HIGH_SPEED },
{ "y","yhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_Y].homing_input, Y_HOMING_INPUT },
{ "y","yhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_Y].homing_dir, Y_HOMING_DIRECTION },
{ "y","ysv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm->a[AXIS_Y].search_velocity,Y_SEARCH_VELOCITY },
{ "y","ylv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm->a[AXIS_Y].latch_velocity, Y_LATCH_VELOCITY },
{ "y","ylb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm->a[AXIS_Y].latch_backoff, Y_LATCH_BACKOFF },
{ "y","yzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm->a[AXIS_Y].zero_backoff, Y_ZERO_BACKOFF },
{ "z","zam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_Z].axis_mode, Z_AXIS_MODE },
{ "z","zvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_Z].velocity_max, Z_VELOCITY_MAX },
{ "z","zfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_Z].feedrate_max, Z_FEEDRATE_MAX },
{ "z","ztn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm.a[AXIS_Z].travel_min, Z_TRAVEL_MIN },
{ "z","ztm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm.a[AXIS_Z].travel_max, Z_TRAVEL_MAX },
{ "z","zjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_Z].jerk_max, Z_JERK_MAX },
{ "z","zjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_Z].jerk_high, Z_JERK_HIGH_SPEED },
{ "z","zhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_Z].homing_input, Z_HOMING_INPUT },
{ "z","zhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_Z].homing_dir, Z_HOMING_DIRECTION },
{ "z","zsv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm.a[AXIS_Z].search_velocity,Z_SEARCH_VELOCITY },
{ "z","zlv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm.a[AXIS_Z].latch_velocity, Z_LATCH_VELOCITY },
{ "z","zlb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm.a[AXIS_Z].latch_backoff, Z_LATCH_BACKOFF },
{ "z","zzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm.a[AXIS_Z].zero_backoff, Z_ZERO_BACKOFF },
{ "z","zam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_Z].axis_mode, Z_AXIS_MODE },
{ "z","zvm",_fipc, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_Z].velocity_max, Z_VELOCITY_MAX },
{ "z","zfr",_fipc, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_Z].feedrate_max, Z_FEEDRATE_MAX },
{ "z","ztn",_fipc, 3, cm_print_tn, get_flt, set_flu, (float *)&cm->a[AXIS_Z].travel_min, Z_TRAVEL_MIN },
{ "z","ztm",_fipc, 3, cm_print_tm, get_flt, set_flu, (float *)&cm->a[AXIS_Z].travel_max, Z_TRAVEL_MAX },
{ "z","zjm",_fipc, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_Z].jerk_max, Z_JERK_MAX },
{ "z","zjh",_fipc, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_Z].jerk_high, Z_JERK_HIGH_SPEED },
{ "z","zhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_Z].homing_input, Z_HOMING_INPUT },
{ "z","zhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_Z].homing_dir, Z_HOMING_DIRECTION },
{ "z","zsv",_fipc, 0, cm_print_sv, get_flt, set_flu, (float *)&cm->a[AXIS_Z].search_velocity,Z_SEARCH_VELOCITY },
{ "z","zlv",_fipc, 2, cm_print_lv, get_flt, set_flu, (float *)&cm->a[AXIS_Z].latch_velocity, Z_LATCH_VELOCITY },
{ "z","zlb",_fipc, 3, cm_print_lb, get_flt, set_flu, (float *)&cm->a[AXIS_Z].latch_backoff, Z_LATCH_BACKOFF },
{ "z","zzb",_fipc, 3, cm_print_zb, get_flt, set_flu, (float *)&cm->a[AXIS_Z].zero_backoff, Z_ZERO_BACKOFF },
{ "a","aam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_A].axis_mode, A_AXIS_MODE },
{ "a","avm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_A].velocity_max, A_VELOCITY_MAX },
{ "a","afr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_A].feedrate_max, A_FEEDRATE_MAX },
{ "a","atn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm.a[AXIS_A].travel_min, A_TRAVEL_MIN },
{ "a","atm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm.a[AXIS_A].travel_max, A_TRAVEL_MAX },
{ "a","ajm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_A].jerk_max, A_JERK_MAX },
{ "a","ajh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_A].jerk_high, A_JERK_HIGH_SPEED },
{ "a","ara",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm.a[AXIS_A].radius, A_RADIUS},
{ "a","ahi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_A].homing_input, A_HOMING_INPUT },
{ "a","ahd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_A].homing_dir, A_HOMING_DIRECTION },
{ "a","asv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm.a[AXIS_A].search_velocity,A_SEARCH_VELOCITY },
{ "a","alv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm.a[AXIS_A].latch_velocity, A_LATCH_VELOCITY },
{ "a","alb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm.a[AXIS_A].latch_backoff, A_LATCH_BACKOFF },
{ "a","azb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm.a[AXIS_A].zero_backoff, A_ZERO_BACKOFF },
{ "a","aam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_A].axis_mode, A_AXIS_MODE },
{ "a","avm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_A].velocity_max, A_VELOCITY_MAX },
{ "a","afr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_A].feedrate_max, A_FEEDRATE_MAX },
{ "a","atn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm->a[AXIS_A].travel_min, A_TRAVEL_MIN },
{ "a","atm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm->a[AXIS_A].travel_max, A_TRAVEL_MAX },
{ "a","ajm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_A].jerk_max, A_JERK_MAX },
{ "a","ajh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_A].jerk_high, A_JERK_HIGH_SPEED },
{ "a","ara",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm->a[AXIS_A].radius, A_RADIUS},
{ "a","ahi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_A].homing_input, A_HOMING_INPUT },
{ "a","ahd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_A].homing_dir, A_HOMING_DIRECTION },
{ "a","asv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm->a[AXIS_A].search_velocity,A_SEARCH_VELOCITY },
{ "a","alv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm->a[AXIS_A].latch_velocity, A_LATCH_VELOCITY },
{ "a","alb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm->a[AXIS_A].latch_backoff, A_LATCH_BACKOFF },
{ "a","azb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm->a[AXIS_A].zero_backoff, A_ZERO_BACKOFF },
{ "b","bam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_B].axis_mode, B_AXIS_MODE },
{ "b","bvm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_B].velocity_max, B_VELOCITY_MAX },
{ "b","bfr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_B].feedrate_max, B_FEEDRATE_MAX },
{ "b","btn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm.a[AXIS_B].travel_min, B_TRAVEL_MIN },
{ "b","btm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm.a[AXIS_B].travel_max, B_TRAVEL_MAX },
{ "b","bjm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_B].jerk_max, B_JERK_MAX },
{ "b","bjh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_B].jerk_high, B_JERK_HIGH_SPEED },
{ "b","bra",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm.a[AXIS_B].radius, B_RADIUS },
{ "b","bhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_B].homing_input, B_HOMING_INPUT },
{ "b","bhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_B].homing_dir, B_HOMING_DIRECTION },
{ "b","bsv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm.a[AXIS_B].search_velocity,B_SEARCH_VELOCITY },
{ "b","blv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm.a[AXIS_B].latch_velocity, B_LATCH_VELOCITY },
{ "b","blb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm.a[AXIS_B].latch_backoff, B_LATCH_BACKOFF },
{ "b","bzb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm.a[AXIS_B].zero_backoff, B_ZERO_BACKOFF },
{ "b","bam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_B].axis_mode, B_AXIS_MODE },
{ "b","bvm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_B].velocity_max, B_VELOCITY_MAX },
{ "b","bfr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_B].feedrate_max, B_FEEDRATE_MAX },
{ "b","btn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm->a[AXIS_B].travel_min, B_TRAVEL_MIN },
{ "b","btm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm->a[AXIS_B].travel_max, B_TRAVEL_MAX },
{ "b","bjm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_B].jerk_max, B_JERK_MAX },
{ "b","bjh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_B].jerk_high, B_JERK_HIGH_SPEED },
{ "b","bra",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm->a[AXIS_B].radius, B_RADIUS },
{ "b","bhi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_B].homing_input, B_HOMING_INPUT },
{ "b","bhd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_B].homing_dir, B_HOMING_DIRECTION },
{ "b","bsv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm->a[AXIS_B].search_velocity,B_SEARCH_VELOCITY },
{ "b","blv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm->a[AXIS_B].latch_velocity, B_LATCH_VELOCITY },
{ "b","blb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm->a[AXIS_B].latch_backoff, B_LATCH_BACKOFF },
{ "b","bzb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm->a[AXIS_B].zero_backoff, B_ZERO_BACKOFF },
{ "c","cam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm.a[AXIS_C].axis_mode, C_AXIS_MODE },
{ "c","cvm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm.a[AXIS_C].velocity_max, C_VELOCITY_MAX },
{ "c","cfr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm.a[AXIS_C].feedrate_max, C_FEEDRATE_MAX },
{ "c","ctn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm.a[AXIS_C].travel_min, C_TRAVEL_MIN },
{ "c","ctm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm.a[AXIS_C].travel_max, C_TRAVEL_MAX },
{ "c","cjm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm.a[AXIS_C].jerk_max, C_JERK_MAX },
{ "c","cjh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm.a[AXIS_C].jerk_high, C_JERK_HIGH_SPEED },
{ "c","cra",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm.a[AXIS_C].radius, C_RADIUS },
{ "c","chi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm.a[AXIS_C].homing_input, C_HOMING_INPUT },
{ "c","chd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm.a[AXIS_C].homing_dir, C_HOMING_DIRECTION },
{ "c","csv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm.a[AXIS_C].search_velocity,C_SEARCH_VELOCITY },
{ "c","clv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm.a[AXIS_C].latch_velocity, C_LATCH_VELOCITY },
{ "c","clb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm.a[AXIS_C].latch_backoff, C_LATCH_BACKOFF },
{ "c","czb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm.a[AXIS_C].zero_backoff, C_ZERO_BACKOFF },
{ "c","cam",_fip, 0, cm_print_am, cm_get_am, cm_set_am, (float *)&cm->a[AXIS_C].axis_mode, C_AXIS_MODE },
{ "c","cvm",_fip, 0, cm_print_vm, get_flt, cm_set_vm, (float *)&cm->a[AXIS_C].velocity_max, C_VELOCITY_MAX },
{ "c","cfr",_fip, 0, cm_print_fr, get_flt, cm_set_fr, (float *)&cm->a[AXIS_C].feedrate_max, C_FEEDRATE_MAX },
{ "c","ctn",_fip, 3, cm_print_tn, get_flt, set_flt, (float *)&cm->a[AXIS_C].travel_min, C_TRAVEL_MIN },
{ "c","ctm",_fip, 3, cm_print_tm, get_flt, set_flt, (float *)&cm->a[AXIS_C].travel_max, C_TRAVEL_MAX },
{ "c","cjm",_fip, 0, cm_print_jm, get_flt, cm_set_jm, (float *)&cm->a[AXIS_C].jerk_max, C_JERK_MAX },
{ "c","cjh",_fip, 0, cm_print_jh, get_flt, cm_set_jh, (float *)&cm->a[AXIS_C].jerk_high, C_JERK_HIGH_SPEED },
{ "c","cra",_fipc, 3, cm_print_ra, get_flt, set_flt, (float *)&cm->a[AXIS_C].radius, C_RADIUS },
{ "c","chi",_fip, 0, cm_print_hi, get_ui8, cm_set_hi, (float *)&cm->a[AXIS_C].homing_input, C_HOMING_INPUT },
{ "c","chd",_fip, 0, cm_print_hd, get_ui8, set_01, (float *)&cm->a[AXIS_C].homing_dir, C_HOMING_DIRECTION },
{ "c","csv",_fip, 0, cm_print_sv, get_flt, set_flt, (float *)&cm->a[AXIS_C].search_velocity,C_SEARCH_VELOCITY },
{ "c","clv",_fip, 2, cm_print_lv, get_flt, set_flt, (float *)&cm->a[AXIS_C].latch_velocity, C_LATCH_VELOCITY },
{ "c","clb",_fip, 3, cm_print_lb, get_flt, set_flt, (float *)&cm->a[AXIS_C].latch_backoff, C_LATCH_BACKOFF },
{ "c","czb",_fip, 3, cm_print_zb, get_flt, set_flt, (float *)&cm->a[AXIS_C].zero_backoff, C_ZERO_BACKOFF },
// Digital input configs
{ "di1","di1mo",_fip, 0, io_print_mo, get_int8,io_set_mo, (float *)&d_in[0].mode, DI1_MODE },
@@ -532,69 +532,69 @@ const cfgItem_t cfgArray[] = {
{ "he3","he3fh",_f0, 1, tx_print_nul, cm_get_fan_high_temp, cm_set_fan_high_temp, (float *)&cs.null, 0 },
// Coordinate system offsets (G54-G59 and G92)
{ "g54","g54x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G54][AXIS_X], G54_X_OFFSET },
{ "g54","g54y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G54][AXIS_Y], G54_Y_OFFSET },
{ "g54","g54z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G54][AXIS_Z], G54_Z_OFFSET },
{ "g54","g54a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G54][AXIS_A], G54_A_OFFSET },
{ "g54","g54b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G54][AXIS_B], G54_B_OFFSET },
{ "g54","g54c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G54][AXIS_C], G54_C_OFFSET },
{ "g54","g54x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G54][AXIS_X], G54_X_OFFSET },
{ "g54","g54y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G54][AXIS_Y], G54_Y_OFFSET },
{ "g54","g54z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G54][AXIS_Z], G54_Z_OFFSET },
{ "g54","g54a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G54][AXIS_A], G54_A_OFFSET },
{ "g54","g54b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G54][AXIS_B], G54_B_OFFSET },
{ "g54","g54c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G54][AXIS_C], G54_C_OFFSET },
{ "g55","g55x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G55][AXIS_X], G55_X_OFFSET },
{ "g55","g55y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G55][AXIS_Y], G55_Y_OFFSET },
{ "g55","g55z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G55][AXIS_Z], G55_Z_OFFSET },
{ "g55","g55a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G55][AXIS_A], G55_A_OFFSET },
{ "g55","g55b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G55][AXIS_B], G55_B_OFFSET },
{ "g55","g55c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G55][AXIS_C], G55_C_OFFSET },
{ "g55","g55x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G55][AXIS_X], G55_X_OFFSET },
{ "g55","g55y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G55][AXIS_Y], G55_Y_OFFSET },
{ "g55","g55z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G55][AXIS_Z], G55_Z_OFFSET },
{ "g55","g55a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G55][AXIS_A], G55_A_OFFSET },
{ "g55","g55b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G55][AXIS_B], G55_B_OFFSET },
{ "g55","g55c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G55][AXIS_C], G55_C_OFFSET },
{ "g56","g56x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G56][AXIS_X], G56_X_OFFSET },
{ "g56","g56y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G56][AXIS_Y], G56_Y_OFFSET },
{ "g56","g56z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G56][AXIS_Z], G56_Z_OFFSET },
{ "g56","g56a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G56][AXIS_A], G56_A_OFFSET },
{ "g56","g56b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G56][AXIS_B], G56_B_OFFSET },
{ "g56","g56c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G56][AXIS_C], G56_C_OFFSET },
{ "g56","g56x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G56][AXIS_X], G56_X_OFFSET },
{ "g56","g56y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G56][AXIS_Y], G56_Y_OFFSET },
{ "g56","g56z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G56][AXIS_Z], G56_Z_OFFSET },
{ "g56","g56a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G56][AXIS_A], G56_A_OFFSET },
{ "g56","g56b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G56][AXIS_B], G56_B_OFFSET },
{ "g56","g56c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G56][AXIS_C], G56_C_OFFSET },
{ "g57","g57x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G57][AXIS_X], G57_X_OFFSET },
{ "g57","g57y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G57][AXIS_Y], G57_Y_OFFSET },
{ "g57","g57z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G57][AXIS_Z], G57_Z_OFFSET },
{ "g57","g57a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G57][AXIS_A], G57_A_OFFSET },
{ "g57","g57b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G57][AXIS_B], G57_B_OFFSET },
{ "g57","g57c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G57][AXIS_C], G57_C_OFFSET },
{ "g57","g57x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G57][AXIS_X], G57_X_OFFSET },
{ "g57","g57y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G57][AXIS_Y], G57_Y_OFFSET },
{ "g57","g57z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G57][AXIS_Z], G57_Z_OFFSET },
{ "g57","g57a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G57][AXIS_A], G57_A_OFFSET },
{ "g57","g57b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G57][AXIS_B], G57_B_OFFSET },
{ "g57","g57c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G57][AXIS_C], G57_C_OFFSET },
{ "g58","g58x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G58][AXIS_X], G58_X_OFFSET },
{ "g58","g58y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G58][AXIS_Y], G58_Y_OFFSET },
{ "g58","g58z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G58][AXIS_Z], G58_Z_OFFSET },
{ "g58","g58a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G58][AXIS_A], G58_A_OFFSET },
{ "g58","g58b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G58][AXIS_B], G58_B_OFFSET },
{ "g58","g58c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G58][AXIS_C], G58_C_OFFSET },
{ "g58","g58x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G58][AXIS_X], G58_X_OFFSET },
{ "g58","g58y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G58][AXIS_Y], G58_Y_OFFSET },
{ "g58","g58z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G58][AXIS_Z], G58_Z_OFFSET },
{ "g58","g58a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G58][AXIS_A], G58_A_OFFSET },
{ "g58","g58b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G58][AXIS_B], G58_B_OFFSET },
{ "g58","g58c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G58][AXIS_C], G58_C_OFFSET },
{ "g59","g59x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G59][AXIS_X], G59_X_OFFSET },
{ "g59","g59y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G59][AXIS_Y], G59_Y_OFFSET },
{ "g59","g59z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm.offset[G59][AXIS_Z], G59_Z_OFFSET },
{ "g59","g59a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G59][AXIS_A], G59_A_OFFSET },
{ "g59","g59b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G59][AXIS_B], G59_B_OFFSET },
{ "g59","g59c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm.offset[G59][AXIS_C], G59_C_OFFSET },
{ "g59","g59x",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G59][AXIS_X], G59_X_OFFSET },
{ "g59","g59y",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G59][AXIS_Y], G59_Y_OFFSET },
{ "g59","g59z",_fipc, 3, cm_print_cofs, get_flt, set_flu,(float *)&cm->offset[G59][AXIS_Z], G59_Z_OFFSET },
{ "g59","g59a",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G59][AXIS_A], G59_A_OFFSET },
{ "g59","g59b",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G59][AXIS_B], G59_B_OFFSET },
{ "g59","g59c",_fip, 3, cm_print_cofs, get_flt, set_flt,(float *)&cm->offset[G59][AXIS_C], G59_C_OFFSET },
{ "g92","g92x",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_X], 0 },// G92 handled differently
{ "g92","g92y",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_Y], 0 },
{ "g92","g92z",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_Z], 0 },
{ "g92","g92a",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_A], 0 },
{ "g92","g92b",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_B], 0 },
{ "g92","g92c",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm.gmx.origin_offset[AXIS_C], 0 },
{ "g92","g92x",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_X], 0 },// G92 handled differently
{ "g92","g92y",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_Y], 0 },
{ "g92","g92z",_fic, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_Z], 0 },
{ "g92","g92a",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_A], 0 },
{ "g92","g92b",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_B], 0 },
{ "g92","g92c",_fi, 3, cm_print_cofs, get_flt, set_nul,(float *)&cm->gmx.origin_offset[AXIS_C], 0 },
// Coordinate positions (G28, G30)
{ "g28","g28x",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_X], 0 },// g28 handled differently
{ "g28","g28y",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_Y], 0 },
{ "g28","g28z",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_Z], 0 },
{ "g28","g28a",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_A], 0 },
{ "g28","g28b",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_B], 0 },
{ "g28","g28c",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g28_position[AXIS_C], 0 },
{ "g28","g28x",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_X], 0 },// g28 handled differently
{ "g28","g28y",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_Y], 0 },
{ "g28","g28z",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_Z], 0 },
{ "g28","g28a",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_A], 0 },
{ "g28","g28b",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_B], 0 },
{ "g28","g28c",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g28_position[AXIS_C], 0 },
{ "g30","g30x",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_X], 0 },// g30 handled differently
{ "g30","g30y",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_Y], 0 },
{ "g30","g30z",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_Z], 0 },
{ "g30","g30a",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_A], 0 },
{ "g30","g30b",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_B], 0 },
{ "g30","g30c",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm.gmx.g30_position[AXIS_C], 0 },
{ "g30","g30x",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_X], 0 },// g30 handled differently
{ "g30","g30y",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_Y], 0 },
{ "g30","g30z",_fic, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_Z], 0 },
{ "g30","g30a",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_A], 0 },
{ "g30","g30b",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_B], 0 },
{ "g30","g30c",_fi, 3, cm_print_cpos, get_flt, set_nul,(float *)&cm->gmx.g30_position[AXIS_C], 0 },
// this is a 128bit UUID for identifying a previously committed job state
{ "jid","jida",_f0, 0, tx_print_nul, get_data, set_data, (float *)&cfg.job_id[0], 0},
@@ -603,16 +603,16 @@ const cfgItem_t cfgArray[] = {
{ "jid","jidd",_f0, 0, tx_print_nul, get_data, set_data, (float *)&cfg.job_id[3], 0},
// General system parameters
{ "sys","jt", _fipn, 2, cm_print_jt, get_flt, cm_set_jt,(float *)&cm.junction_integration_time,JUNCTION_INTEGRATION_TIME },
{ "sys","ct", _fipnc,4, cm_print_ct, get_flt, set_flu, (float *)&cm.chordal_tolerance, CHORDAL_TOLERANCE },
{ "sys","sl", _fipn, 0, cm_print_sl, get_ui8, set_01, (float *)&cm.soft_limit_enable, SOFT_LIMIT_ENABLE },
{ "sys","lim", _fipn,0, cm_print_lim, get_ui8, set_01, (float *)&cm.limit_enable, HARD_LIMIT_ENABLE },
{ "sys","saf", _fipn,0, cm_print_saf, get_ui8, set_01, (float *)&cm.safety_interlock_enable, SAFETY_INTERLOCK_ENABLE },
{ "sys","m48e",_fipn,0, cm_print_m48e,get_ui8, set_01, (float *)&cm.gmx.m48_enable, 0 }, // M48/M49 feedrate & spindle override enable
{ "sys","mfoe",_fipn,0, cm_print_mfoe,get_ui8, set_01, (float *)&cm.gmx.mfo_enable, FEED_OVERRIDE_ENABLE},
{ "sys","mfo", _fipn,3, cm_print_mfo, get_flt,cm_set_mfo,(float *)&cm.gmx.mfo_factor, FEED_OVERRIDE_FACTOR},
{ "sys","mtoe",_fipn,0, cm_print_mtoe,get_ui8, set_01, (float *)&cm.gmx.mto_enable, TRAVERSE_OVERRIDE_ENABLE},
{ "sys","mto", _fipn,3, cm_print_mto, get_flt,cm_set_mto,(float *)&cm.gmx.mto_factor, TRAVERSE_OVERRIDE_FACTOR},
{ "sys","jt", _fipn, 2, cm_print_jt, get_flt, cm_set_jt,(float *)&cm->junction_integration_time,JUNCTION_INTEGRATION_TIME },
{ "sys","ct", _fipnc,4, cm_print_ct, get_flt, set_flu, (float *)&cm->chordal_tolerance, CHORDAL_TOLERANCE },
{ "sys","sl", _fipn, 0, cm_print_sl, get_ui8, set_01, (float *)&cm->soft_limit_enable, SOFT_LIMIT_ENABLE },
{ "sys","lim", _fipn,0, cm_print_lim, get_ui8, set_01, (float *)&cm->limit_enable, HARD_LIMIT_ENABLE },
{ "sys","saf", _fipn,0, cm_print_saf, get_ui8, set_01, (float *)&cm->safety_interlock_enable, SAFETY_INTERLOCK_ENABLE },
{ "sys","m48e",_fipn,0, cm_print_m48e,get_ui8, set_01, (float *)&cm->gmx.m48_enable, 0 }, // M48/M49 feedrate & spindle override enable
{ "sys","mfoe",_fipn,0, cm_print_mfoe,get_ui8, set_01, (float *)&cm->gmx.mfo_enable, FEED_OVERRIDE_ENABLE},
{ "sys","mfo", _fipn,3, cm_print_mfo, get_flt,cm_set_mfo,(float *)&cm->gmx.mfo_factor, FEED_OVERRIDE_FACTOR},
{ "sys","mtoe",_fipn,0, cm_print_mtoe,get_ui8, set_01, (float *)&cm->gmx.mto_enable, TRAVERSE_OVERRIDE_ENABLE},
{ "sys","mto", _fipn,3, cm_print_mto, get_flt,cm_set_mto,(float *)&cm->gmx.mto_factor, TRAVERSE_OVERRIDE_FACTOR},
{ "sys","mt", _fipn,2, st_print_mt, get_flt, st_set_mt,(float *)&st_cfg.motor_power_timeout, MOTOR_POWER_TIMEOUT},
{ "", "me", _f0, 0, st_print_me, get_nul, st_set_me,(float *)&cs.null, 0 }, // GET or SET to enable motors
{ "", "md", _f0, 0, st_print_md, get_nul, st_set_md,(float *)&cs.null, 0 }, // GET or SET to disable motors
@@ -647,11 +647,11 @@ const cfgItem_t cfgArray[] = {
// Gcode defaults
// NOTE: The ordering within the gcode defaults is important for token resolution. gc must follow gco
{ "sys","gpl", _fipn, 0, cm_print_gpl, get_ui8, set_012, (float *)&cm.default_select_plane, GCODE_DEFAULT_PLANE },
{ "sys","gun", _fipn, 0, cm_print_gun, get_ui8, set_01, (float *)&cm.default_units_mode, GCODE_DEFAULT_UNITS },
{ "sys","gco", _fipn, 0, cm_print_gco, get_ui8, set_ui8, (float *)&cm.default_coord_system, GCODE_DEFAULT_COORD_SYSTEM },
{ "sys","gpa", _fipn, 0, cm_print_gpa, get_ui8, set_012, (float *)&cm.default_path_control, GCODE_DEFAULT_PATH_CONTROL },
{ "sys","gdi", _fipn, 0, cm_print_gdi, get_ui8, set_01, (float *)&cm.default_distance_mode, GCODE_DEFAULT_DISTANCE_MODE },
{ "sys","gpl", _fipn, 0, cm_print_gpl, get_ui8, set_012, (float *)&cm->default_select_plane, GCODE_DEFAULT_PLANE },
{ "sys","gun", _fipn, 0, cm_print_gun, get_ui8, set_01, (float *)&cm->default_units_mode, GCODE_DEFAULT_UNITS },
{ "sys","gco", _fipn, 0, cm_print_gco, get_ui8, set_ui8, (float *)&cm->default_coord_system, GCODE_DEFAULT_COORD_SYSTEM },
{ "sys","gpa", _fipn, 0, cm_print_gpa, get_ui8, set_012, (float *)&cm->default_path_control, GCODE_DEFAULT_PATH_CONTROL },
{ "sys","gdi", _fipn, 0, cm_print_gdi, get_ui8, set_01, (float *)&cm->default_distance_mode, GCODE_DEFAULT_DISTANCE_MODE },
{ "", "gc", _f0, 0, tx_print_nul, gc_get_gc,gc_run_gc,(float *)&cs.null, 0 }, // gcode block - must be last in this group
// Actions and Reports
g2core/controller.cpp
+13 -13
View File
@@ -371,10 +371,10 @@ static stat_t _sync_to_planner()
*/
static stat_t _shutdown_handler(void)
{
if (cm.shutdown_requested != 0) { // request may contain the (non-zero) input number
if (cm->shutdown_requested != 0) { // request may contain the (non-zero) input number
char msg[10];
sprintf(msg, "input %d", (int)cm.shutdown_requested);
cm.shutdown_requested = false; // clear limit request used here ^
sprintf(msg, "input %d", (int)cm->shutdown_requested);
cm->shutdown_requested = false; // clear limit request used here ^
cm_shutdown(STAT_SHUTDOWN, msg);
}
return(STAT_OK);
@@ -389,10 +389,10 @@ static stat_t _limit_switch_handler(void)
// safe_pin = 1;
if ((cm.limit_enable == true) && (cm.limit_requested != 0)) {
if ((cm->limit_enable == true) && (cm->limit_requested != 0)) {
char msg[10];
sprintf(msg, "input %d", (int)cm.limit_requested);
cm.limit_requested = false; // clear limit request used here ^
sprintf(msg, "input %d", (int)cm->limit_requested);
cm->limit_requested = false; // clear limit request used here ^
cm_alarm(STAT_LIMIT_SWITCH_HIT, msg);
}
return (STAT_OK);
@@ -400,11 +400,11 @@ static stat_t _limit_switch_handler(void)
static stat_t _interlock_handler(void)
{
if (cm.safety_interlock_enable) {
if (cm->safety_interlock_enable) {
// interlock broken
if (cm.safety_interlock_disengaged != 0) {
cm.safety_interlock_disengaged = 0;
cm.safety_interlock_state = SAFETY_INTERLOCK_DISENGAGED;
if (cm->safety_interlock_disengaged != 0) {
cm->safety_interlock_disengaged = 0;
cm->safety_interlock_state = SAFETY_INTERLOCK_DISENGAGED;
cm_request_feedhold(); // may have already requested STOP as INPUT_ACTION
// feedhold was initiated by input action in gpio
// pause spindle
@@ -412,9 +412,9 @@ static stat_t _interlock_handler(void)
}
// interlock restored
if ((cm.safety_interlock_reengaged != 0) && (mp_runtime_is_idle())) {
cm.safety_interlock_reengaged = 0;
cm.safety_interlock_state = SAFETY_INTERLOCK_ENGAGED; // interlock restored
if ((cm->safety_interlock_reengaged != 0) && (mp_runtime_is_idle())) {
cm->safety_interlock_reengaged = 0;
cm->safety_interlock_state = SAFETY_INTERLOCK_ENGAGED; // interlock restored
// restart spindle with dwell
cm_request_end_hold(); // use cm_request_end_hold() instead of just ending
// restart coolant
g2core/cycle_homing.cpp
Executable → Regular
+54 -54
View File
@@ -172,9 +172,9 @@ stat_t cm_homing_cycle_start(void) {
hm.axis = -1; // set to retrieve initial axis
hm.func = _homing_axis_start; // bind initial processing function
cm.machine_state = MACHINE_CYCLE;
cm.cycle_state = CYCLE_HOMING;
cm.homing_state = HOMING_NOT_HOMED;
cm->machine_state = MACHINE_CYCLE;
cm->cycle_state = CYCLE_HOMING;
cm->homing_state = HOMING_NOT_HOMED;
return (STAT_OK);
}
@@ -185,7 +185,7 @@ stat_t cm_homing_cycle_start_no_set(void) {
}
stat_t cm_homing_cycle_callback(void) {
if (cm.cycle_state != CYCLE_HOMING) { // exit if not in a homing cycle
if (cm->cycle_state != CYCLE_HOMING) { // exit if not in a homing cycle
return (STAT_NOOP);
}
if (hm.waiting_for_motion_end) { // sync to planner move ends (using callback)
@@ -210,57 +210,57 @@ static stat_t _homing_axis_start(int8_t axis) {
// get the first or next axis
if ((axis = _get_next_axis(axis)) < 0) { // axes are done or error
if (axis == -1) { // -1 is done
cm.homing_state = HOMING_HOMED;
cm->homing_state = HOMING_HOMED;
return (_set_homing_func(_homing_finalize_exit));
} else if (axis == -2) { // -2 is error
return (_homing_error_exit(-2, STAT_HOMING_ERROR_BAD_OR_NO_AXIS));
}
}
// clear the homed flag for axis so we'll be able to move w/o triggering soft limits
cm.homed[axis] = false;
cm->homed[axis] = false;
// trap axis mis-configurations
if (fp_ZERO(cm.a[axis].homing_input)) {
if (fp_ZERO(cm->a[axis].homing_input)) {
return (_homing_error_exit(axis, STAT_HOMING_ERROR_HOMING_INPUT_MISCONFIGURED));
}
if (fp_ZERO(cm.a[axis].search_velocity)) {
if (fp_ZERO(cm->a[axis].search_velocity)) {
return (_homing_error_exit(axis, STAT_HOMING_ERROR_ZERO_SEARCH_VELOCITY));
}
if (fp_ZERO(cm.a[axis].latch_velocity)) {
if (fp_ZERO(cm->a[axis].latch_velocity)) {
return (_homing_error_exit(axis, STAT_HOMING_ERROR_ZERO_LATCH_VELOCITY));
}
// calculate and test travel distance
float travel_distance = fabs(cm.a[axis].travel_max - cm.a[axis].travel_min) + cm.a[axis].latch_backoff;
float travel_distance = fabs(cm->a[axis].travel_max - cm->a[axis].travel_min) + cm->a[axis].latch_backoff;
if (fp_ZERO(travel_distance)) {
return (_homing_error_exit(axis, STAT_HOMING_ERROR_TRAVEL_MIN_MAX_IDENTICAL));
}
// Nothing to do about direction now that direction is explicit
// However, here's a good place to stash the homing_switch:
hm.homing_input = cm.a[axis].homing_input;
hm.homing_input = cm->a[axis].homing_input;
gpio_set_homing_mode(hm.homing_input, true);
hm.axis = axis; // persist the axis
hm.search_velocity = fabs(cm.a[axis].search_velocity); // search velocity is always positive
hm.latch_velocity = fabs(cm.a[axis].latch_velocity); // latch velocity is always positive
hm.search_velocity = fabs(cm->a[axis].search_velocity); // search velocity is always positive
hm.latch_velocity = fabs(cm->a[axis].latch_velocity); // latch velocity is always positive
bool homing_to_max = cm.a[axis].homing_dir;
bool homing_to_max = cm->a[axis].homing_dir;
// setup parameters for positive or negative travel (homing to the max or min switch)
if (homing_to_max) {
hm.search_travel = travel_distance; // search travels in positive direction
hm.latch_backoff = fabs(cm.a[axis].latch_backoff); // latch travels in positive direction
hm.zero_backoff = -max(0.0f, cm.a[axis].zero_backoff); // zero backoff is negative direction (or zero)
hm.latch_backoff = fabs(cm->a[axis].latch_backoff); // latch travels in positive direction
hm.zero_backoff = -max(0.0f, cm->a[axis].zero_backoff); // zero backoff is negative direction (or zero)
// will set the maximum position
// (plus any negative backoff)
hm.setpoint = cm.a[axis].travel_max + (max(0.0f, -cm.a[axis].zero_backoff));
hm.setpoint = cm->a[axis].travel_max + (max(0.0f, -cm->a[axis].zero_backoff));
} else {
hm.search_travel = -travel_distance; // search travels in negative direction
hm.latch_backoff = -fabs(cm.a[axis].latch_backoff); // latch travels in negative direction
hm.zero_backoff = max(0.0f, cm.a[axis].zero_backoff); // zero backoff is positive direction (or zero)
hm.latch_backoff = -fabs(cm->a[axis].latch_backoff); // latch travels in negative direction
hm.zero_backoff = max(0.0f, cm->a[axis].zero_backoff); // zero backoff is positive direction (or zero)
// will set the minimum position
// (minus any negative backoff)
hm.setpoint = cm.a[axis].travel_min + (max(0.0f, -cm.a[axis].zero_backoff));
hm.setpoint = cm->a[axis].travel_min + (max(0.0f, -cm->a[axis].zero_backoff));
}
// if homing is disabled for the axis then skip to the next axis
@@ -276,7 +276,7 @@ static stat_t _homing_axis_clear_init(int8_t axis) // first clear move
// determine if the input switch for this axis is shared w/other axes
for (uint8_t check_axis = AXIS_X; check_axis < AXES; check_axis++) {
if (axis != check_axis && cm.a[check_axis].homing_input == hm.homing_input) {
if (axis != check_axis && cm->a[check_axis].homing_input == hm.homing_input) {
return (_homing_error_exit(
axis, STAT_HOMING_ERROR_MUST_CLEAR_SWITCHES_BEFORE_HOMING)); // axis cannot be homed
}
@@ -288,7 +288,7 @@ static stat_t _homing_axis_clear_init(int8_t axis) // first clear move
static stat_t _homing_axis_search(int8_t axis) // drive to switch
{
cm_set_axis_jerk(axis, cm.a[axis].jerk_high); // use the high-speed jerk for search onward
cm_set_axis_jerk(axis, cm->a[axis].jerk_high); // use the high-speed jerk for search onward
_homing_axis_move(axis, hm.search_travel, hm.search_velocity);
return (_set_homing_func(_homing_axis_clear));
}
@@ -315,7 +315,7 @@ static stat_t _homing_axis_set_position(int8_t axis) // set axis zero / max and
{
if (hm.set_coordinates) {
cm_set_position(axis, hm.setpoint);
cm.homed[axis] = true;
cm->homed[axis] = true;
} else { // handle G28.4 cycle - set position to the point of switch closure
float contact_position[AXES];
@@ -407,38 +407,38 @@ static stat_t _homing_finalize_exit(int8_t axis) // third part of return to hom
static int8_t _get_next_axis(int8_t axis) {
#if (HOMING_AXES <= 4)
if (axis == -1) { // inelegant brute force solution
if (cm.gf.target[AXIS_Z]) {
if (cm->gf.target[AXIS_Z]) {
return (AXIS_Z);
}
if (cm.gf.target[AXIS_X]) {
if (cm->gf.target[AXIS_X]) {
return (AXIS_X);
}
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
return (-2); // error
} else if (axis == AXIS_Z) {
if (cm.gf.target[AXIS_X]) {
if (cm->gf.target[AXIS_X]) {
return (AXIS_X);
}
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
} else if (axis == AXIS_X) {
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
} else if (axis == AXIS_Y) {
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
}
@@ -446,73 +446,73 @@ static int8_t _get_next_axis(int8_t axis) {
#else
if (axis == -1) {
if (cm.gf.target[AXIS_Z]) {
if (cm->gf.target[AXIS_Z]) {
return (AXIS_Z);
}
if (cm.gf.target[AXIS_X]) {
if (cm->gf.target[AXIS_X]) {
return (AXIS_X);
}
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
if (cm.gf.target[AXIS_B]) {
if (cm->gf.target[AXIS_B]) {
return (AXIS_B);
}
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
return (-2); // error
} else if (axis == AXIS_Z) {
if (cm.gf.target[AXIS_X]) {
if (cm->gf.target[AXIS_X]) {
return (AXIS_X);
}
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
if (cm.gf.target[AXIS_B]) {
if (cm->gf.target[AXIS_B]) {
return (AXIS_B);
}
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
} else if (axis == AXIS_X) {
if (cm.gf.target[AXIS_Y]) {
if (cm->gf.target[AXIS_Y]) {
return (AXIS_Y);
}
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
if (cm.gf.target[AXIS_B]) {
if (cm->gf.target[AXIS_B]) {
return (AXIS_B);
}
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
} else if (axis == AXIS_Y) {
if (cm.gf.target[AXIS_A]) {
if (cm->gf.target[AXIS_A]) {
return (AXIS_A);
}
if (cm.gf.target[AXIS_B]) {
if (cm->gf.target[AXIS_B]) {
return (AXIS_B);
}
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
} else if (axis == AXIS_A) {
if (cm.gf.target[AXIS_B]) {
if (cm->gf.target[AXIS_B]) {
return (AXIS_B);
}
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
} else if (axis == AXIS_B) {
if (cm.gf.target[AXIS_C]) {
if (cm->gf.target[AXIS_C]) {
return (AXIS_C);
}
}
g2core/cycle_jogging.cpp
+9 -9
View File
@@ -84,12 +84,12 @@ static stat_t _jogging_finalize_exit(int8_t axis);
stat_t cm_jogging_cycle_start(uint8_t axis) {
// save relevant non-axis parameters from Gcode model
jog.saved_units_mode = cm_get_units_mode(ACTIVE_MODEL); // cm.gm.units_mode;
jog.saved_coord_system = cm_get_coord_system(ACTIVE_MODEL); // cm.gm.coord_system;
jog.saved_distance_mode = cm_get_distance_mode(ACTIVE_MODEL); // cm.gm.distance_mode;
jog.saved_units_mode = cm_get_units_mode(ACTIVE_MODEL); // cm->gm.units_mode;
jog.saved_coord_system = cm_get_coord_system(ACTIVE_MODEL); // cm->gm.coord_system;
jog.saved_distance_mode = cm_get_distance_mode(ACTIVE_MODEL); // cm->gm.distance_mode;
jog.saved_feed_rate_mode = cm_get_feed_rate_mode(ACTIVE_MODEL);
jog.saved_feed_rate = (ACTIVE_MODEL)->feed_rate; // cm.gm.feed_rate;
jog.saved_jerk = cm.a[axis].jerk_max;
jog.saved_feed_rate = (ACTIVE_MODEL)->feed_rate; // cm->gm.feed_rate;
jog.saved_jerk = cm->a[axis].jerk_max;
// set working values
cm_set_units_mode(MILLIMETERS);
@@ -98,7 +98,7 @@ stat_t cm_jogging_cycle_start(uint8_t axis) {
cm_set_feed_rate_mode(UNITS_PER_MINUTE_MODE);
jog.velocity_start = JOGGING_START_VELOCITY; // see canonical_machine.h for #define
jog.velocity_max = cm.a[axis].velocity_max;
jog.velocity_max = cm->a[axis].velocity_max;
jog.start_pos = cm_get_absolute_position(RUNTIME, axis);
jog.dest_pos = cm_get_jogging_dest();
@@ -107,8 +107,8 @@ stat_t cm_jogging_cycle_start(uint8_t axis) {
jog.axis = axis;
jog.func = _jogging_axis_start; // bind initial processing function
cm.machine_state = MACHINE_CYCLE;
cm.cycle_state = CYCLE_JOG;
cm->machine_state = MACHINE_CYCLE;
cm->cycle_state = CYCLE_JOG;
return (STAT_OK);
}
@@ -123,7 +123,7 @@ stat_t cm_jogging_cycle_start(uint8_t axis) {
*/
stat_t cm_jogging_cycle_callback(void) {
if (cm.cycle_state != CYCLE_JOG) {
if (cm->cycle_state != CYCLE_JOG) {
return (STAT_NOOP); // exit if not in a jogging cycle
}
if (jog.func == _jogging_finalize_exit && cm_get_runtime_busy() == true) {
g2core/cycle_probing.cpp
Executable → Regular
+34 -34
View File
@@ -130,8 +130,8 @@ static stat_t _set_pb_func(uint8_t (*func)()) {
* in-progress) occupies one of those positions, wich is the one reported by the
* "prb" JSON.
*
* Internally we store the active/most recent probe in cm.probe_results[0] and
* cm.probe_state[0]. Before we start a new probe, if cm.probe_state[0] ==
* Internally we store the active/most recent probe in cm->probe_results[0] and
* cm->probe_state[0]. Before we start a new probe, if cm->probe_state[0] ==
* PROBE_SUCCEEDED, then we roll 0 to 1, and 1 to 2, up to PROBES_STORED-1.
* The oldest probe is "lost."
*
@@ -139,7 +139,7 @@ static stat_t _set_pb_func(uint8_t (*func)()) {
uint8_t cm_straight_probe(float target[], bool flags[], bool failure_is_fatal, bool moving_toward_switch) {
// trap zero feed rate condition
if (fp_ZERO(cm.gm.feed_rate)) {
if (fp_ZERO(cm->gm.feed_rate)) {
return (STAT_GCODE_FEEDRATE_NOT_SPECIFIED);
}
@@ -156,19 +156,19 @@ uint8_t cm_straight_probe(float target[], bool flags[], bool failure_is_fatal, b
copy_vector(pb.flags, flags); // set axes involved on the move
// if the previous probe succeeded, roll probes to the next position
if (cm.probe_state[0] == PROBE_SUCCEEDED) {
if (cm->probe_state[0] == PROBE_SUCCEEDED) {
for (uint8_t n = PROBES_STORED - 1; n > 0; n--) {
cm.probe_state[n] = cm.probe_state[n - 1];
for (uint8_t axis = 0; axis < AXES; axis++) { cm.probe_results[n][axis] = cm.probe_results[n - 1][axis]; }
cm->probe_state[n] = cm->probe_state[n - 1];
for (uint8_t axis = 0; axis < AXES; axis++) { cm->probe_results[n][axis] = cm->probe_results[n - 1][axis]; }
}
}
// clear the old probe position
clear_vector(cm.probe_results[0]);
clear_vector(cm->probe_results[0]);
// NOTE: relying on probe_result will not detect a probe to 0,0,0.
cm.probe_state[0] = PROBE_WAITING; // wait until planner queue empties before completing initialization
cm->probe_state[0] = PROBE_WAITING; // wait until planner queue empties before completing initialization
pb.waiting_for_motion_end = true;
// queue a function to let us know when we can start probing
@@ -195,7 +195,7 @@ uint8_t cm_straight_probe(float target[], bool flags[], bool failure_is_fatal, b
*/
uint8_t cm_probing_cycle_callback(void) {
if ((cm.cycle_state != CYCLE_PROBE) && (cm.probe_state[0] != PROBE_WAITING)) { // exit if not in a homing cycle
if ((cm->cycle_state != CYCLE_PROBE) && (cm->probe_state[0] != PROBE_WAITING)) { // exit if not in a homing cycle
return (STAT_NOOP);
}
if (pb.waiting_for_motion_end) { // sync to planner move ends (using callback)
@@ -219,9 +219,9 @@ static uint8_t _probing_init() {
// so optimistic... ;)
// NOTE: it is *not* an error condition for the probe not to trigger.
// it is an error for the limit or homing switches to fire, or for some other configuration error.
cm.probe_state[0] = PROBE_FAILED;
cm.machine_state = MACHINE_CYCLE;
cm.cycle_state = CYCLE_PROBE;
cm->probe_state[0] = PROBE_FAILED;
cm->machine_state = MACHINE_CYCLE;
cm->cycle_state = CYCLE_PROBE;
// save relevant non-axis parameters from Gcode model
pb.saved_coord_system = cm_get_coord_system(ACTIVE_MODEL);
@@ -234,7 +234,7 @@ static uint8_t _probing_init() {
// initialize the axes - save the jerk settings & switch to the jerk_homing settings
for (uint8_t axis = 0; axis < AXES; axis++) {
pb.saved_jerk[axis] = cm_get_axis_jerk(axis); // save the max jerk value
cm_set_axis_jerk(axis, cm.a[axis].jerk_high); // use the high-speed jerk for probe
cm_set_axis_jerk(axis, cm->a[axis].jerk_high); // use the high-speed jerk for probe
start_position[axis] = cm_get_absolute_position(ACTIVE_MODEL, axis);
}
@@ -254,10 +254,10 @@ static uint8_t _probing_init() {
// initialize the probe switch
// TODO -- for now we hard code it to z homing switch
if (fp_ZERO(cm.a[AXIS_Z].homing_input)) {
if (fp_ZERO(cm->a[AXIS_Z].homing_input)) {
return (_probing_error_exit(-2));
}
pb.probe_input = cm.a[AXIS_Z].homing_input;
pb.probe_input = cm->a[AXIS_Z].homing_input;
gpio_set_probing_mode(pb.probe_input, true);
// turn off spindle and start the move
@@ -281,7 +281,7 @@ static stat_t _probing_start() {
return (_set_pb_func(_probing_backoff));
}
cm.probe_state[0] = PROBE_FAILED; // we failed
cm->probe_state[0] = PROBE_FAILED; // we failed
return (_set_pb_func(_probing_finish));
}
@@ -299,7 +299,7 @@ static stat_t _probing_backoff() {
// INPUT_INACTIVE is the right end condition for G38.4 and G38.5
// Note that we're testing for SUCCESS here
if (probe == (pb.moving_toward_switch ? INPUT_ACTIVE : INPUT_INACTIVE)) {
cm.probe_state[0] = PROBE_SUCCEEDED;
cm->probe_state[0] = PROBE_SUCCEEDED;
// capture contact position in step space and convert from steps to mm.
// snapshot was taken by switch interrupt at the time of closure
@@ -308,18 +308,18 @@ static stat_t _probing_backoff() {
_probe_axis_move(contact_position, true); // NB: feed rate is the same as the probe move
} else {
cm.probe_state[0] = PROBE_FAILED;
cm->probe_state[0] = PROBE_FAILED;
}
return (_set_pb_func(_probing_finish));
}
static stat_t _probe_axis_move(const float target[], bool exact_position) {
auto stored_units_mode = cm.gm.units_mode;
auto stored_distance_mode = cm.gm.distance_mode;
auto stored_units_mode = cm->gm.units_mode;
auto stored_distance_mode = cm->gm.distance_mode;
if (exact_position) {
cm_set_absolute_override(MODEL, ABSOLUTE_OVERRIDE_ON); // Position was stored in absolute coords
cm.gm.units_mode = MILLIMETERS;
cm.gm.distance_mode = ABSOLUTE_MODE;
cm->gm.units_mode = MILLIMETERS;
cm->gm.distance_mode = ABSOLUTE_MODE;
}
for (uint8_t axis = AXIS_X; axis < AXES; axis++) { // set all positions
@@ -332,8 +332,8 @@ static stat_t _probe_axis_move(const float target[], bool exact_position) {
cm_straight_feed(target, pb.flags);
if (exact_position) {
cm.gm.units_mode = stored_units_mode;
cm.gm.distance_mode = stored_distance_mode;
cm->gm.units_mode = stored_units_mode;
cm->gm.distance_mode = stored_distance_mode;
}
// the last two arguments are ignored anyway
@@ -350,30 +350,30 @@ static void _probe_axis_move_callback(float* vect, bool* flag) { pb.waiting_for_
static stat_t _probing_finish() {
for (uint8_t axis = 0; axis < AXES; axis++) {
cm.probe_results[0][axis] = cm_get_absolute_position(ACTIVE_MODEL, axis);
cm->probe_results[0][axis] = cm_get_absolute_position(ACTIVE_MODEL, axis);
}
// If probe was successful the 'e' word == 1, otherwise e == 0 to signal an error
char buf[32];
char* bufp = buf;
bufp += sprintf(bufp, "{\"prb\":{\"e\":%i, \"", (int)cm.probe_state[0]);
bufp += sprintf(bufp, "{\"prb\":{\"e\":%i, \"", (int)cm->probe_state[0]);
if (pb.flags[AXIS_X]) {
sprintf(bufp, "x\":%0.3f}}\n", cm.probe_results[0][AXIS_X]);
sprintf(bufp, "x\":%0.3f}}\n", cm->probe_results[0][AXIS_X]);
}
if (pb.flags[AXIS_Y]) {
sprintf(bufp, "y\":%0.3f}}\n", cm.probe_results[0][AXIS_Y]);
sprintf(bufp, "y\":%0.3f}}\n", cm->probe_results[0][AXIS_Y]);
}
if (pb.flags[AXIS_Z]) {
sprintf(bufp, "z\":%0.3f}}\n", cm.probe_results[0][AXIS_Z]);
sprintf(bufp, "z\":%0.3f}}\n", cm->probe_results[0][AXIS_Z]);
}
if (pb.flags[AXIS_A]) {
sprintf(bufp, "a\":%0.3f}}\n", cm.probe_results[0][AXIS_A]);
sprintf(bufp, "a\":%0.3f}}\n", cm->probe_results[0][AXIS_A]);
}
if (pb.flags[AXIS_B]) {
sprintf(bufp, "b\":%0.3f}}\n", cm.probe_results[0][AXIS_B]);
sprintf(bufp, "b\":%0.3f}}\n", cm->probe_results[0][AXIS_B]);
}
if (pb.flags[AXIS_C]) {
sprintf(bufp, "c\":%0.3f}}\n", cm.probe_results[0][AXIS_C]);
sprintf(bufp, "c\":%0.3f}}\n", cm->probe_results[0][AXIS_C]);
}
xio_writeline(buf);
@@ -391,7 +391,7 @@ static void _probe_restore_settings() {
gpio_set_probing_mode(pb.probe_input, false);
// restore axis jerk
for (uint8_t axis = 0; axis < AXES; axis++) { cm.a[axis].jerk_max = pb.saved_jerk[axis]; }
for (uint8_t axis = 0; axis < AXES; axis++) { cm->a[axis].jerk_max = pb.saved_jerk[axis]; }
// restore coordinate system and distance mode
cm_set_coord_system(pb.saved_coord_system);
@@ -407,7 +407,7 @@ static void _probe_restore_settings() {
static stat_t _probing_finalize_exit() {
_probe_restore_settings();
if (cm.probe_state[0] == PROBE_SUCCEEDED) {
if (cm->probe_state[0] == PROBE_SUCCEEDED) {
return (STAT_OK);
}
g2core/gcode_parser.cpp
+38 -38
View File
@@ -35,9 +35,9 @@ static stat_t _validate_gcode_block(char *active_comment);
static stat_t _parse_gcode_block(char *line, char *active_comment); // Parse the block into the GN/GF structs
static stat_t _execute_gcode_block(char *active_comment); // Execute the gcode block
#define SET_MODAL(m,parm,val) ({cm.gn.parm=val; cm.gf.parm=true; cm.gf.modals[m]=true; break;})
#define SET_NON_MODAL(parm,val) ({cm.gn.parm=val; cm.gf.parm=true; break;})
#define EXEC_FUNC(f,v) if(cm.gf.v) { status=f(cm.gn.v);}
#define SET_MODAL(m,parm,val) ({cm->gn.parm=val; cm->gf.parm=true; cm->gf.modals[m]=true; break;})
#define SET_NON_MODAL(parm,val) ({cm->gn.parm=val; cm->gf.parm=true; break;})
#define EXEC_FUNC(f,v) if(cm->gf.v) { status=f(cm->gn.v);}
/*
* gcode_parser() - parse a block (line) of gcode
@@ -387,12 +387,12 @@ static stat_t _validate_gcode_block(char *active_comment)
// uses axis words appears on the line, the activity of the group 1 G-code is suspended
// for that line. The axis word-using G-codes from group 0 are G10, G28, G30, and G92"
// if ((cm.gn.modals[MODAL_GROUP_G0] == true) && (cm.gn.modals[MODAL_GROUP_G1] == true)) {
// if ((cm->gn.modals[MODAL_GROUP_G0] == true) && (cm->gn.modals[MODAL_GROUP_G1] == true)) {
// return (STAT_MODAL_GROUP_VIOLATION);
// }
// look for commands that require an axis word to be present
// if ((cm.gn.modals[MODAL_GROUP_G0] == true) || (cm.gn.modals[MODAL_GROUP_G1] == true)) {
// if ((cm->gn.modals[MODAL_GROUP_G0] == true) || (cm->gn.modals[MODAL_GROUP_G1] == true)) {
// if (_axis_changed() == false)
// return (STAT_GCODE_AXIS_IS_MISSING);
// }
@@ -415,16 +415,16 @@ static stat_t _parse_gcode_block(char *buf, char *active_comment)
stat_t status = STAT_OK;
// set initial state for new move
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
memset(&cm.gf, 0, sizeof(GCodeFlags_t)); // clear all next-state flags
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
memset(&cm->gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
memset(&cm->gf, 0, sizeof(GCodeFlags_t)); // clear all next-state flags
cm->gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
// Causes a later exception if
// (1) INVERSE_TIME_MODE is active and a feed rate is not provided or
// (2) INVERSE_TIME_MODE is changed to UNITS_PER_MINUTE and a new feed rate is missing
if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE) {// new feed rate req'd when in INV_TIME_MODE
cm.gn.feed_rate = 0;
cm.gf.feed_rate = true;
if (cm->gm.feed_rate_mode == INVERSE_TIME_MODE) {// new feed rate req'd when in INV_TIME_MODE
cm->gn.feed_rate = 0;
cm->gf.feed_rate = true;
}
// extract commands and parameters
@@ -620,7 +620,7 @@ static stat_t _execute_gcode_block(char *active_comment)
{
stat_t status = STAT_OK;
cm_set_model_linenum(cm.gn.linenum);
cm_set_model_linenum(cm->gn.linenum);
EXEC_FUNC(cm_set_feed_rate_mode, feed_rate_mode); // G93, G94
EXEC_FUNC(cm_set_feed_rate, feed_rate); // F
EXEC_FUNC(cm_set_spindle_speed, spindle_speed); // S
@@ -642,8 +642,8 @@ static stat_t _execute_gcode_block(char *active_comment)
// EXEC_FUNC(cm_mfo_enable, feed_rate_override_factor);
// EXEC_FUNC(cm_sso_enable, sso_enable);
if (cm.gn.next_action == NEXT_ACTION_DWELL) { // G4 - dwell
ritorno(cm_dwell(cm.gn.parameter)); // return if error, otherwise complete the block
if (cm->gn.next_action == NEXT_ACTION_DWELL) { // G4 - dwell
ritorno(cm_dwell(cm->gn.parameter)); // return if error, otherwise complete the block
}
EXEC_FUNC(cm_select_plane, select_plane); // G17, G18, G19
EXEC_FUNC(cm_set_units_mode, units_mode); // G20, G21
@@ -651,29 +651,29 @@ static stat_t _execute_gcode_block(char *active_comment)
//--> cutter length compensation goes here
EXEC_FUNC(cm_set_coord_system, coord_system); // G54, G55, G56, G57, G58, G59
// EXEC_FUNC(cm_set_path_control, path_control); // G61, G61.1, G64
if(cm.gf.path_control) { status = cm_set_path_control(MODEL, cm.gn.path_control); }
if(cm->gf.path_control) { status = cm_set_path_control(MODEL, cm->gn.path_control); }
EXEC_FUNC(cm_set_distance_mode, distance_mode); // G90, G91
EXEC_FUNC(cm_set_arc_distance_mode, arc_distance_mode); // G90.1, G91.1
//--> set retract mode goes here
switch (cm.gn.next_action) {
switch (cm->gn.next_action) {
case NEXT_ACTION_SET_G28_POSITION: { status = cm_set_g28_position(); break;} // G28.1
case NEXT_ACTION_GOTO_G28_POSITION: { status = cm_goto_g28_position(cm.gn.target, cm.gf.target); break;} // G28
case NEXT_ACTION_GOTO_G28_POSITION: { status = cm_goto_g28_position(cm->gn.target, cm->gf.target); break;} // G28
case NEXT_ACTION_SET_G30_POSITION: { status = cm_set_g30_position(); break;} // G30.1
case NEXT_ACTION_GOTO_G30_POSITION: { status = cm_goto_g30_position(cm.gn.target, cm.gf.target); break;} // G30
case NEXT_ACTION_GOTO_G30_POSITION: { status = cm_goto_g30_position(cm->gn.target, cm->gf.target); break;} // G30
case NEXT_ACTION_SEARCH_HOME: { status = cm_homing_cycle_start(); break;} // G28.2
case NEXT_ACTION_SET_ABSOLUTE_ORIGIN: { status = cm_set_absolute_origin(cm.gn.target, cm.gf.target); break;}// G28.3
case NEXT_ACTION_SET_ABSOLUTE_ORIGIN: { status = cm_set_absolute_origin(cm->gn.target, cm->gf.target); break;}// G28.3
case NEXT_ACTION_HOMING_NO_SET: { status = cm_homing_cycle_start_no_set(); break;} // G28.4
case NEXT_ACTION_STRAIGHT_PROBE_ERR: { status = cm_straight_probe(cm.gn.target, cm.gf.target, true, true); break;} // G38.2
case NEXT_ACTION_STRAIGHT_PROBE: { status = cm_straight_probe(cm.gn.target, cm.gf.target, false, true); break;} // G38.3
case NEXT_ACTION_STRAIGHT_PROBE_AWAY_ERR:{ status = cm_straight_probe(cm.gn.target, cm.gf.target, true, false); break;} // G38.4
case NEXT_ACTION_STRAIGHT_PROBE_AWAY: { status = cm_straight_probe(cm.gn.target, cm.gf.target, false, false); break;} // G38.5
case NEXT_ACTION_STRAIGHT_PROBE_ERR: { status = cm_straight_probe(cm->gn.target, cm->gf.target, true, true); break;} // G38.2
case NEXT_ACTION_STRAIGHT_PROBE: { status = cm_straight_probe(cm->gn.target, cm->gf.target, false, true); break;} // G38.3
case NEXT_ACTION_STRAIGHT_PROBE_AWAY_ERR:{ status = cm_straight_probe(cm->gn.target, cm->gf.target, true, false); break;} // G38.4
case NEXT_ACTION_STRAIGHT_PROBE_AWAY: { status = cm_straight_probe(cm->gn.target, cm->gf.target, false, false); break;} // G38.5
case NEXT_ACTION_SET_COORD_DATA: { status = cm_set_coord_offsets(cm.gn.parameter, cm.gn.L_word, cm.gn.target, cm.gf.target); break;}
case NEXT_ACTION_SET_ORIGIN_OFFSETS: { status = cm_set_origin_offsets(cm.gn.target, cm.gf.target); break;}// G92
case NEXT_ACTION_SET_COORD_DATA: { status = cm_set_coord_offsets(cm->gn.parameter, cm->gn.L_word, cm->gn.target, cm->gf.target); break;}
case NEXT_ACTION_SET_ORIGIN_OFFSETS: { status = cm_set_origin_offsets(cm->gn.target, cm->gf.target); break;}// G92
case NEXT_ACTION_RESET_ORIGIN_OFFSETS: { status = cm_reset_origin_offsets(); break;} // G92.1
case NEXT_ACTION_SUSPEND_ORIGIN_OFFSETS: { status = cm_suspend_origin_offsets(); break;} // G92.2
case NEXT_ACTION_RESUME_ORIGIN_OFFSETS: { status = cm_resume_origin_offsets(); break;} // G92.3
@@ -683,18 +683,18 @@ static stat_t _execute_gcode_block(char *active_comment)
// case NEXT_ACTION_JSON_COMMAND_IMMEDIATE: { status = mp_json_command_immediate(active_comment); break;} // M102
case NEXT_ACTION_DEFAULT: {
cm_set_absolute_override(MODEL, cm.gn.absolute_override); // apply absolute override
switch (cm.gn.motion_mode) {
case MOTION_MODE_CANCEL_MOTION_MODE: { cm.gm.motion_mode = cm.gn.motion_mode; break;} // G80
case MOTION_MODE_STRAIGHT_TRAVERSE: { status = cm_straight_traverse(cm.gn.target, cm.gf.target); break;} // G0
case MOTION_MODE_STRAIGHT_FEED: { status = cm_straight_feed(cm.gn.target, cm.gf.target); break;} // G1
cm_set_absolute_override(MODEL, cm->gn.absolute_override); // apply absolute override
switch (cm->gn.motion_mode) {
case MOTION_MODE_CANCEL_MOTION_MODE: { cm->gm.motion_mode = cm->gn.motion_mode; break;} // G80
case MOTION_MODE_STRAIGHT_TRAVERSE: { status = cm_straight_traverse(cm->gn.target, cm->gf.target); break;} // G0
case MOTION_MODE_STRAIGHT_FEED: { status = cm_straight_feed(cm->gn.target, cm->gf.target); break;} // G1
case MOTION_MODE_CW_ARC: // G2
case MOTION_MODE_CCW_ARC: { status = cm_arc_feed(cm.gn.target, cm.gf.target, // G3
cm.gn.arc_offset, cm.gf.arc_offset,
cm.gn.arc_radius, cm.gf.arc_radius,
cm.gn.parameter, cm.gf.parameter,
cm.gf.modals[MODAL_GROUP_G1],
cm.gn.motion_mode);
case MOTION_MODE_CCW_ARC: { status = cm_arc_feed(cm->gn.target, cm->gf.target, // G3
cm->gn.arc_offset, cm->gf.arc_offset,
cm->gn.arc_radius, cm->gf.arc_radius,
cm->gn.parameter, cm->gf.parameter,
cm->gf.modals[MODAL_GROUP_G1],
cm->gn.motion_mode);
break;
}
default: break;
@@ -704,8 +704,8 @@ static stat_t _execute_gcode_block(char *active_comment)
}
// do the program stops and ends : M0, M1, M2, M30, M60
if (cm.gf.program_flow == true) {
if (cm.gn.program_flow == PROGRAM_STOP) {
if (cm->gf.program_flow == true) {
if (cm->gn.program_flow == PROGRAM_STOP) {
cm_program_stop();
} else {
cm_program_end();
g2core/gpio.cpp
Executable → Regular
+4 -4
View File
@@ -194,20 +194,20 @@ struct ioDigitalInputExt {
// these functions trigger on the leading edge
if (in->edge == INPUT_EDGE_LEADING) {
if (in->function == INPUT_FUNCTION_LIMIT) {
cm.limit_requested = ext_pin_number;
cm->limit_requested = ext_pin_number;
} else if (in->function == INPUT_FUNCTION_SHUTDOWN) {
cm.shutdown_requested = ext_pin_number;
cm->shutdown_requested = ext_pin_number;
} else if (in->function == INPUT_FUNCTION_INTERLOCK) {
cm.safety_interlock_disengaged = ext_pin_number;
cm->safety_interlock_disengaged = ext_pin_number;
}
}
// trigger interlock release on trailing edge
if (in->edge == INPUT_EDGE_TRAILING) {
if (in->function == INPUT_FUNCTION_INTERLOCK) {
cm.safety_interlock_reengaged = ext_pin_number;
cm->safety_interlock_reengaged = ext_pin_number;
}
}
g2core/json_parser.cpp
Executable → Regular
+2 -2
View File
@@ -529,7 +529,7 @@ void json_print_response(uint8_t status)
}
if (js.json_verbosity == JV_EXCEPTIONS) { // cutout for JV_EXCEPTIONS mode
if (status == STAT_OK) {
if (cm.machine_state != MACHINE_INITIALIZING) { // always do full echo during startup
if (cm->machine_state != MACHINE_INITIALIZING) { // always do full echo during startup
return;
}
}
@@ -541,7 +541,7 @@ void json_print_response(uint8_t status)
nv_reset_nv_list();
nv_add_string((const char *)"err", escape_string(cs.bufp, cs.saved_buf));
} else if ((cm.machine_state != MACHINE_INITIALIZING) || (status == STAT_INITIALIZING)) { // always do full echo during startup
} else if ((cm->machine_state != MACHINE_INITIALIZING) || (status == STAT_INITIALIZING)) { // always do full echo during startup
uint8_t nv_type;
do {
if ((nv_type = nv_get_type(nv)) == NV_TYPE_NULL) break;
g2core/kinematics.cpp
Executable → Regular
+3 -3
View File
@@ -57,7 +57,7 @@ void kn_inverse_kinematics(const float travel[], float steps[]) {
// Most of the conversion math has already been done in during config in steps_per_unit()
// which takes axis travel, step angle and microsteps into account.
for (uint8_t axis=0; axis<AXES; axis++) {
if (cm.a[axis].axis_mode == AXIS_INHIBITED) { joint[axis] = 0;}
if (cm->a[axis].axis_mode == AXIS_INHIBITED) { joint[axis] = 0;}
if (st_cfg.mot[MOTOR_1].motor_map == axis) {
steps[MOTOR_1] = joint[axis] * st_cfg.mot[MOTOR_1].steps_per_unit;
}
@@ -85,7 +85,7 @@ void kn_inverse_kinematics(const float travel[], float steps[]) {
#else
for (uint8_t axis = 0; axis < AXES; axis++) {
if (cm.a[axis].axis_mode == AXIS_INHIBITED) {
if (cm->a[axis].axis_mode == AXIS_INHIBITED) {
joint[axis] = 0;
continue;
}
@@ -141,7 +141,7 @@ void kn_forward_kinematics(const float steps[], float travel[]) {
// Scan through each axis, and then through each motor
for (uint8_t axis = 0; axis < AXES; axis++) {
if (cm.a[axis].axis_mode == AXIS_INHIBITED) {
if (cm->a[axis].axis_mode == AXIS_INHIBITED) {
travel[axis] = 0.0;
continue;
}
g2core/main.cpp
Executable → Regular
+2 -1
View File
@@ -101,7 +101,8 @@ void application_init_services(void)
void application_init_machine(void)
{
cm.machine_state = MACHINE_INITIALIZING;
cm = &cm0;
cm->machine_state = MACHINE_INITIALIZING;
stepper_init(); // stepper subsystem
encoder_init(); // virtual encoders
g2core/persistence.cpp
Executable → Regular
+1 -1
View File
@@ -71,7 +71,7 @@ stat_t read_persistent_value(nvObj_t *nv)
stat_t write_persistent_value(nvObj_t *nv)
{
if (cm.cycle_state != CYCLE_OFF) { // can't write when machine is moving
if (cm->cycle_state != CYCLE_OFF) { // can't write when machine is moving
return(rpt_exception(STAT_FILE_NOT_OPEN, "write_persistent_value() can't write when machine is in cycle"));
}
return (STAT_OK);
g2core/plan_arc.cpp
+22 -22
View File
@@ -135,21 +135,21 @@ stat_t cm_arc_feed(const float target[], const bool target_f[], // target en
// - rotary axes are present. Ignored
// trap missing feed rate
if (fp_ZERO(cm.gm.feed_rate)) {
if (fp_ZERO(cm->gm.feed_rate)) {
return (STAT_GCODE_FEEDRATE_NOT_SPECIFIED);
}
// Set the arc plane for the current G17/G18/G19 setting and test arc specification
// Plane axis 0 and 1 are the arc plane, the linear axis is normal to the arc plane.
if (cm.gm.select_plane == CANON_PLANE_XY) { // G17 - the vast majority of arcs are in the G17 (XY) plane
if (cm->gm.select_plane == CANON_PLANE_XY) { // G17 - the vast majority of arcs are in the G17 (XY) plane
arc.plane_axis_0 = AXIS_X;
arc.plane_axis_1 = AXIS_Y;
arc.linear_axis = AXIS_Z;
} else if (cm.gm.select_plane == CANON_PLANE_XZ) { // G18
} else if (cm->gm.select_plane == CANON_PLANE_XZ) { // G18
arc.plane_axis_0 = AXIS_X;
arc.plane_axis_1 = AXIS_Z;
arc.linear_axis = AXIS_Y;
} else if (cm.gm.select_plane == CANON_PLANE_YZ) { // G19
} else if (cm->gm.select_plane == CANON_PLANE_YZ) { // G19
arc.plane_axis_0 = AXIS_Y;
arc.plane_axis_1 = AXIS_Z;
arc.linear_axis = AXIS_X;
@@ -175,7 +175,7 @@ stat_t cm_arc_feed(const float target[], const bool target_f[], // target en
}
}
else { // test that center format absolute distance mode arcs have both offsets specified
if (cm.gm.arc_distance_mode == ABSOLUTE_MODE) {
if (cm->gm.arc_distance_mode == ABSOLUTE_MODE) {
if (!(offset_f[arc.plane_axis_0] && offset_f[arc.plane_axis_1])) { // if one or both offsets are missing
return (STAT_ARC_OFFSETS_MISSING_FOR_SELECTED_PLANE);
}
@@ -204,18 +204,18 @@ stat_t cm_arc_feed(const float target[], const bool target_f[], // target en
// in radius mode it's an error for start == end
if (radius_f) {
if ((fp_EQ(cm.gmx.position[AXIS_X], cm.gm.target[AXIS_X])) &&
(fp_EQ(cm.gmx.position[AXIS_Y], cm.gm.target[AXIS_Y])) &&
(fp_EQ(cm.gmx.position[AXIS_Z], cm.gm.target[AXIS_Z]))) {
if ((fp_EQ(cm->gmx.position[AXIS_X], cm->gm.target[AXIS_X])) &&
(fp_EQ(cm->gmx.position[AXIS_Y], cm->gm.target[AXIS_Y])) &&
(fp_EQ(cm->gmx.position[AXIS_Z], cm->gm.target[AXIS_Z]))) {
return (STAT_ARC_ENDPOINT_IS_STARTING_POINT);
}
}
// *** now get down to the rest of the work setting up the arc for execution ***
cm.gm.motion_mode = motion_mode;
cm_set_work_offsets(&cm.gm); // capture the fully resolved offsets to gm
memcpy(&arc.gm, &cm.gm, sizeof(GCodeState_t)); // copy GCode context to arc singleton - some will be overwritten to run segments
copy_vector(arc.position, cm.gmx.position); // set initial arc position from gcode model
cm->gm.motion_mode = motion_mode;
cm_set_work_offsets(&cm->gm); // capture the fully resolved offsets to gm
memcpy(&arc.gm, &cm->gm, sizeof(GCodeState_t)); // copy GCode context to arc singleton - some will be overwritten to run segments
copy_vector(arc.position, cm->gmx.position); // set initial arc position from gcode model
// setup offsets
arc.offset[OFS_I] = _to_millimeters(offset[OFS_I]); // copy offsets with conversion to canonical form (mm)
@@ -240,8 +240,8 @@ stat_t cm_arc_feed(const float target[], const bool target_f[], // target en
// test arc soft limits
stat_t status = _test_arc_soft_limits();
if (status != STAT_OK) {
cm.gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE;
copy_vector(cm.gm.target, arc.position); // reset model position
cm->gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE;
copy_vector(cm->gm.target, arc.position); // reset model position
return (cm_alarm(status, "arc soft_limits")); // throw an alarm
}
@@ -333,7 +333,7 @@ static stat_t _compute_arc(const bool radius_f)
// Note: removed segment_length test as segment_time accounts for this (build 083.37)
float arc_time;
float segments_for_minimum_time = _estimate_arc_time(arc_time) * (MICROSECONDS_PER_MINUTE / MIN_ARC_SEGMENT_USEC);
float segments_for_chordal_accuracy = arc.length / sqrt(4*cm.chordal_tolerance * (2 * arc.radius - cm.chordal_tolerance));
float segments_for_chordal_accuracy = arc.length / sqrt(4*cm->chordal_tolerance * (2 * arc.radius - cm->chordal_tolerance));
arc.segments = floor(min(segments_for_chordal_accuracy, segments_for_minimum_time));
arc.segments = max(arc.segments, (float)1.0); //...but is at least 1 segment
@@ -482,14 +482,14 @@ static float _estimate_arc_time (float arc_time)
if (arc.gm.feed_rate_mode == INVERSE_TIME_MODE) {
arc_time = arc.gm.feed_rate; // inverse feed rate has been normalized to minutes
} else {
arc_time = arc.length / cm.gm.feed_rate;
arc_time = arc.length / cm->gm.feed_rate;
}
// Downgrade the time if there is a rate-limiting axis
arc_time = max(arc_time, (float)fabs(arc.planar_travel/cm.a[arc.plane_axis_0].feedrate_max));
arc_time = max(arc_time, (float)fabs(arc.planar_travel/cm.a[arc.plane_axis_1].feedrate_max));
arc_time = max(arc_time, (float)fabs(arc.planar_travel/cm->a[arc.plane_axis_0].feedrate_max));
arc_time = max(arc_time, (float)fabs(arc.planar_travel/cm->a[arc.plane_axis_1].feedrate_max));
if (fabs(arc.linear_travel) > 0) {
arc_time = max(arc_time, (float)fabs(arc.linear_travel/cm.a[arc.linear_axis].feedrate_max));
arc_time = max(arc_time, (float)fabs(arc.linear_travel/cm->a[arc.linear_axis].feedrate_max));
}
return (arc_time);
}
@@ -555,11 +555,11 @@ static stat_t _test_arc_soft_limit_plane_axis(float center, uint8_t plane_axis)
if (arc.angular_travel < M_PI) { // case (1)
return (STAT_OK);
}
if ((center - arc.radius) < cm.a[plane_axis].travel_min) { // case (2)
if ((center - arc.radius) < cm->a[plane_axis].travel_min) { // case (2)
return (STAT_SOFT_LIMIT_EXCEEDED);
}
}
if ((center + arc.radius) > cm.a[plane_axis].travel_max) { // cases (3) and (4)
if ((center + arc.radius) > cm->a[plane_axis].travel_max) { // cases (3) and (4)
return (STAT_SOFT_LIMIT_EXCEEDED);
}
return(STAT_OK);
@@ -568,7 +568,7 @@ static stat_t _test_arc_soft_limit_plane_axis(float center, uint8_t plane_axis)
static stat_t _test_arc_soft_limits()
{
/*
if (cm.soft_limit_enable == true) {
if (cm->soft_limit_enable == true) {
// Test if target falls outside boundaries. This is a 3 dimensional test
// so it also checks the linear axis of the arc (helix axis)
g2core/plan_exec.cpp
+25 -25
View File
@@ -253,7 +253,7 @@ stat_t mp_exec_move()
// first-time operations
if (bf->buffer_state != MP_BUFFER_RUNNING) {
if ((bf->buffer_state < MP_BUFFER_PREPPED) && (cm.motion_state == MOTION_RUN)) {
if ((bf->buffer_state < MP_BUFFER_PREPPED) && (cm->motion_state == MOTION_RUN)) {
__asm__("BKPT"); // mp_exec_move() buffer is not prepped
// IMPORTANT: We can't rpt_exception from here!
st_prep_null();
@@ -266,7 +266,7 @@ stat_t mp_exec_move()
}
if (bf->buffer_state == MP_BUFFER_PREPPED) {
if (cm.motion_state == MOTION_RUN) {
if (cm->motion_state == MOTION_RUN) {
__asm__("BKPT"); // we are running but don't have a block planned
}
// We need to have it planned. We don't want to do this here, as it
@@ -292,7 +292,7 @@ stat_t mp_exec_move()
}
// Manage motion state transitions
if ((cm.motion_state != MOTION_RUN) && (cm.motion_state != MOTION_HOLD)) {
if ((cm->motion_state != MOTION_RUN) && (cm->motion_state != MOTION_HOLD)) {
cm_set_motion_state(MOTION_RUN);
}
}
@@ -519,20 +519,20 @@ stat_t mp_exec_aline(mpBuf_t *bf)
// (8) - We are removing the hold state and there is queued motion (handled outside this routine)
// (9) - We are removing the hold state and there is no queued motion (also handled outside this routine)
if (cm.motion_state == MOTION_HOLD) {
if (cm->motion_state == MOTION_HOLD) {
// Case (7) - all motion has ceased
if (cm.hold_state == FEEDHOLD_HOLD) {
if (cm->hold_state == FEEDHOLD_HOLD) {
return (STAT_NOOP); // VERY IMPORTANT to exit as a NOOP. No more movement
}
// Case (6) - wait for the steppers to stop
if (cm.hold_state == FEEDHOLD_PENDING) {
if (cm->hold_state == FEEDHOLD_PENDING) {
if (mp_runtime_is_idle()) { // wait for the steppers to actually clear out
if ((cm.cycle_state == CYCLE_HOMING) || (cm.cycle_state == CYCLE_PROBE)) {
if ((cm->cycle_state == CYCLE_HOMING) || (cm->cycle_state == CYCLE_PROBE)) {
// when homing, we don't need to stay in HOLD
cm.hold_state = FEEDHOLD_OFF;
cm->hold_state = FEEDHOLD_OFF;
} else {
cm.hold_state = FEEDHOLD_HOLD;
cm->hold_state = FEEDHOLD_HOLD;
}
mp_zero_segment_velocity(); // for reporting purposes
sr_request_status_report(SR_REQUEST_IMMEDIATE); // was SR_REQUEST_TIMED
@@ -543,16 +543,16 @@ stat_t mp_exec_aline(mpBuf_t *bf)
// Case (5) - decelerated to zero
// Update the run buffer then force a replan of the whole planner queue
if (cm.hold_state == FEEDHOLD_DECEL_END) {
if (cm->hold_state == FEEDHOLD_DECEL_END) {
mr.block_state = BLOCK_INACTIVE; // invalidate mr buffer to reset the new move
bf->block_state = BLOCK_INITIAL_ACTION; // tell _exec to re-use the bf buffer
bf->length = get_axis_vector_length(mr.target, mr.position);// reset length
//bf->entry_vmax = 0; // set bp+0 as hold point
cm.hold_state = FEEDHOLD_PENDING;
cm->hold_state = FEEDHOLD_PENDING;
// No point bothering with the rest of this move if homing or probing
if ((cm.cycle_state == CYCLE_HOMING) || (cm.cycle_state == CYCLE_PROBE)) {
if ((cm->cycle_state == CYCLE_HOMING) || (cm->cycle_state == CYCLE_PROBE)) {
mp_free_run_buffer();
}
@@ -564,15 +564,15 @@ stat_t mp_exec_aline(mpBuf_t *bf)
// Cases (1a, 1b), Case (2), Case (4)
// Build a tail-only move from here. Decelerate as fast as possible in the space we have.
if ((cm.hold_state == FEEDHOLD_SYNC) ||
((cm.hold_state == FEEDHOLD_DECEL_CONTINUE) && (mr.block_state == BLOCK_INITIAL_ACTION))) {
if ((cm->hold_state == FEEDHOLD_SYNC) ||
((cm->hold_state == FEEDHOLD_DECEL_CONTINUE) && (mr.block_state == BLOCK_INITIAL_ACTION))) {
// Case (3a) - already decelerating, continue the deceleration.
if (mr.section == SECTION_TAIL) { // if already in a tail don't decelerate. You already are
if (fp_ZERO(mr.r->exit_velocity)) {
cm.hold_state = FEEDHOLD_DECEL_TO_ZERO;
cm->hold_state = FEEDHOLD_DECEL_TO_ZERO;
} else {
cm.hold_state = FEEDHOLD_DECEL_CONTINUE;
cm->hold_state = FEEDHOLD_DECEL_CONTINUE;
}
// Case (3b) - currently accelerating - is simply skipped and waited for
@@ -590,17 +590,17 @@ stat_t mp_exec_aline(mpBuf_t *bf)
mr.r->tail_length = mp_get_target_length(0, mr.r->cruise_velocity, bf); // braking length
if (fp_ZERO(available_length - mr.r->tail_length)) { // (1c) the deceleration time is almost exactly the remaining of the current move
cm.hold_state = FEEDHOLD_DECEL_TO_ZERO;
cm->hold_state = FEEDHOLD_DECEL_TO_ZERO;
mr.r->tail_length = available_length;
mr.r->exit_velocity = 0;
} else if (available_length < mr.r->tail_length) { // (1b) the deceleration has to span multiple moves
cm.hold_state = FEEDHOLD_DECEL_CONTINUE;
cm->hold_state = FEEDHOLD_DECEL_CONTINUE;
mr.r->tail_length = available_length;
mr.r->exit_velocity = mp_get_decel_velocity(mr.r->cruise_velocity, mr.r->tail_length, bf);
} else { // (1a)the deceleration will fit into the current move
cm.hold_state = FEEDHOLD_DECEL_TO_ZERO;
cm->hold_state = FEEDHOLD_DECEL_TO_ZERO;
mr.r->exit_velocity = 0;
}
mr.r->tail_time = mr.r->tail_length*2 / (mr.r->exit_velocity + mr.r->cruise_velocity);
@@ -627,8 +627,8 @@ stat_t mp_exec_aline(mpBuf_t *bf)
}
// Feedhold Case (5): Look for the end of the deceleration to go into HOLD state
if ((cm.hold_state == FEEDHOLD_DECEL_TO_ZERO) && (status == STAT_OK)) {
cm.hold_state = FEEDHOLD_DECEL_END;
if ((cm->hold_state == FEEDHOLD_DECEL_TO_ZERO) && (status == STAT_OK)) {
cm->hold_state = FEEDHOLD_DECEL_END;
bf->block_state = BLOCK_INITIAL_ACTION; // reset bf so it can restart the rest of the move
}
@@ -652,7 +652,7 @@ stat_t mp_exec_aline(mpBuf_t *bf)
if (bf->block_state == BLOCK_ACTIVE) {
if (mp_free_run_buffer()) { // returns true of the buffer is empty
if (cm.hold_state == FEEDHOLD_OFF) {
if (cm->hold_state == FEEDHOLD_OFF) {
cm_cycle_end(); // free buffer & end cycle if planner is empty
}
} else {
@@ -677,7 +677,7 @@ stat_t mp_plan_feedhold_move()
/*
* mp_exit_hold_state() - end a feedhold
*
* Feedhold is executed as cm.hold_state transitions executed inside _exec_aline()
* Feedhold is executed as cm->hold_state transitions executed inside _exec_aline()
* Invoke a feedhold by calling cm_request_hold() or cm_start_hold() directly
* Return from feedhold by calling cm_request_end_hold() or cm_end_hold directly.
* See canonical_macine.c for a more detailed explanation of feedhold operation.
@@ -685,7 +685,7 @@ stat_t mp_plan_feedhold_move()
void mp_exit_hold_state()
{
cm.hold_state = FEEDHOLD_OFF;
cm->hold_state = FEEDHOLD_OFF;
if (mp_has_runnable_buffer(ACTIVE_Q)) {
cm_set_motion_state(MOTION_RUN);
sr_request_status_report(SR_REQUEST_IMMEDIATE);
@@ -1029,7 +1029,7 @@ static stat_t _exec_aline_segment()
// Otherwise if not at a section waypoint compute target from segment time and velocity
// Don't do waypoint correction if you are going into a hold.
if ((--mr.segment_count == 0) && (cm.motion_state != MOTION_HOLD)) {
if ((--mr.segment_count == 0) && (cm->motion_state != MOTION_HOLD)) {
copy_vector(mr.gm.target, mr.waypoint[mr.section]);
} else {
float segment_length = mr.segment_velocity * mr.segment_time;
g2core/plan_line.cpp
+29 -29
View File
@@ -87,14 +87,14 @@ float mp_get_runtime_work_position(uint8_t axis) {
// target_rotated[2] = a z_1 + b z_2 + c z_3 + z_offset
if (axis == AXIS_X) {
return mr.position[0] * cm.rotation_matrix[0][0] + mr.position[1] * cm.rotation_matrix[1][0] +
mr.position[2] * cm.rotation_matrix[2][0] - mr.gm.work_offset[0];
return mr.position[0] * cm->rotation_matrix[0][0] + mr.position[1] * cm->rotation_matrix[1][0] +
mr.position[2] * cm->rotation_matrix[2][0] - mr.gm.work_offset[0];
} else if (axis == AXIS_Y) {
return mr.position[0] * cm.rotation_matrix[0][1] + mr.position[1] * cm.rotation_matrix[1][1] +
mr.position[2] * cm.rotation_matrix[2][1] - mr.gm.work_offset[1];
return mr.position[0] * cm->rotation_matrix[0][1] + mr.position[1] * cm->rotation_matrix[1][1] +
mr.position[2] * cm->rotation_matrix[2][1] - mr.gm.work_offset[1];
} else if (axis == AXIS_Z) {
return mr.position[0] * cm.rotation_matrix[0][2] + mr.position[1] * cm.rotation_matrix[1][2] +
mr.position[2] * cm.rotation_matrix[2][2] - cm.rotation_z_offset - mr.gm.work_offset[2];
return mr.position[0] * cm->rotation_matrix[0][2] + mr.position[1] * cm->rotation_matrix[1][2] +
mr.position[2] * cm->rotation_matrix[2][2] - cm->rotation_z_offset - mr.gm.work_offset[2];
} else {
// ABC, UVW, we don't rotate them
return (mr.position[axis] - mr.gm.work_offset[axis]);
@@ -110,7 +110,7 @@ float mp_get_runtime_work_position(uint8_t axis) {
*/
bool mp_get_runtime_busy()
{
if (cm.cycle_state == CYCLE_OFF) {
if (cm->cycle_state == CYCLE_OFF) {
return (false);
}
if ((st_runtime_isbusy() == true) ||
@@ -165,20 +165,20 @@ stat_t mp_aline(GCodeState_t* gm_in)
// a being target[0],
// b being target[1],
// c being target[2],
// x_1 being cm.rotation_matrix[1][0]
// x_1 being cm->rotation_matrix[1][0]
target_rotated[0] = gm_in->target[0] * cm.rotation_matrix[0][0] +
gm_in->target[1] * cm.rotation_matrix[0][1] +
gm_in->target[2] * cm.rotation_matrix[0][2];
target_rotated[0] = gm_in->target[0] * cm->rotation_matrix[0][0] +
gm_in->target[1] * cm->rotation_matrix[0][1] +
gm_in->target[2] * cm->rotation_matrix[0][2];
target_rotated[1] = gm_in->target[0] * cm.rotation_matrix[1][0] +
gm_in->target[1] * cm.rotation_matrix[1][1] +
gm_in->target[2] * cm.rotation_matrix[1][2];
target_rotated[1] = gm_in->target[0] * cm->rotation_matrix[1][0] +
gm_in->target[1] * cm->rotation_matrix[1][1] +
gm_in->target[2] * cm->rotation_matrix[1][2];
target_rotated[2] = gm_in->target[0] * cm.rotation_matrix[2][0] +
gm_in->target[1] * cm.rotation_matrix[2][1] +
gm_in->target[2] * cm.rotation_matrix[2][2] +
cm.rotation_z_offset;
target_rotated[2] = gm_in->target[0] * cm->rotation_matrix[2][0] +
gm_in->target[1] * cm->rotation_matrix[2][1] +
gm_in->target[2] * cm->rotation_matrix[2][2] +
cm->rotation_z_offset;
// copy rotation axes ABC
target_rotated[3] = gm_in->target[3];
@@ -256,7 +256,7 @@ void mp_plan_block_list()
}
// OK to replan running buffer during feedhold, but no other times (not supposed to happen)
if ((cm.hold_state == FEEDHOLD_OFF) && (bf->buffer_state == MP_BUFFER_RUNNING)) {
if ((cm->hold_state == FEEDHOLD_OFF) && (bf->buffer_state == MP_BUFFER_RUNNING)) {
mp.p = mp.p->nx;
return;
}
@@ -267,7 +267,7 @@ void mp_plan_block_list()
mp.p = bf; //+++++ DIAGNOSTIC - this is not needed but is set here for debugging purposes
}
if (mp.planner_state > PLANNER_STARTUP) {
if (planned_something && (cm.hold_state != FEEDHOLD_HOLD)) {
if (planned_something && (cm->hold_state != FEEDHOLD_HOLD)) {
st_request_forward_plan(); // start motion if runtime is not already busy
}
}
@@ -452,7 +452,7 @@ static void _calculate_override(mpBuf_t* bf) // execute ramp to adjust cruise v
// TODO: Account for rapid overrides as well as feed overrides
// pull in override factor from previous block or seed initial value from the system setting
bf->override_factor = fp_ZERO(bf->pv->override_factor) ? cm.gmx.mfo_factor : bf->pv->override_factor;
bf->override_factor = fp_ZERO(bf->pv->override_factor) ? cm->gmx.mfo_factor : bf->pv->override_factor;
bf->cruise_vmax = bf->override_factor * bf->cruise_vset;
// generate ramp term is a ramp is active
@@ -518,13 +518,13 @@ static void _calculate_jerk(mpBuf_t* bf)
switch (bf->gm.motion_mode) {
case MOTION_MODE_STRAIGHT_TRAVERSE:
//case MOTION_MODE_STRAIGHT_PROBE: // <-- not sure on this one
axis_jerk = cm.a[axis].jerk_high;
axis_jerk = cm->a[axis].jerk_high;
break;
default:
axis_jerk = cm.a[axis].jerk_max;
axis_jerk = cm->a[axis].jerk_max;
}
#else
axis_jerk = cm.a[axis].jerk_max;
axis_jerk = cm->a[axis].jerk_max;
#endif
jerk = axis_jerk / fabs(bf->unit[axis]);
@@ -630,9 +630,9 @@ static void _calculate_vmaxes(mpBuf_t* bf, const float axis_length[], const floa
for (uint8_t axis = AXIS_X; axis < AXES; axis++) {
if (bf->axis_flags[axis]) {
if (bf->gm.motion_mode == MOTION_MODE_STRAIGHT_TRAVERSE) {
tmp_time = fabs(axis_length[axis]) / cm.a[axis].velocity_max;
tmp_time = fabs(axis_length[axis]) / cm->a[axis].velocity_max;
} else { // gm.motion_mode == MOTION_MODE_STRAIGHT_FEED
tmp_time = fabs(axis_length[axis]) / cm.a[axis].feedrate_max;
tmp_time = fabs(axis_length[axis]) / cm->a[axis].feedrate_max;
}
max_time = max(max_time, tmp_time);
@@ -716,9 +716,9 @@ static void _calculate_junction_vmax(mpBuf_t* bf)
if (delta > EPSILON) {
// formula (4): (See Note 1, above)
// velocity = min(velocity, (cm.a[axis].max_junction_accel / delta));
if ((cm.a[axis].max_junction_accel / delta) < velocity) {
velocity = (cm.a[axis].max_junction_accel / delta);
// velocity = min(velocity, (cm->a[axis].max_junction_accel / delta));
if ((cm->a[axis].max_junction_accel / delta) < velocity) {
velocity = (cm->a[axis].max_junction_accel / delta);
// bf->jerk_axis = axis;
}
}
g2core/planner.cpp
+6 -6
View File
@@ -466,7 +466,7 @@ bool mp_has_runnable_buffer(int8_t q) // which queue are you interested in?)
bool mp_is_phat_city_time()
{
if(cm.hold_state == FEEDHOLD_HOLD) {
if(cm->hold_state == FEEDHOLD_HOLD) {
return true;
}
return ((mp.plannable_time <= 0.0) || (PHAT_CITY_TIME < mp.plannable_time));
@@ -510,8 +510,8 @@ stat_t mp_planner_callback()
{
// Test if the planner has transitioned to an IDLE state
if ((mp_get_planner_buffers(ACTIVE_Q) == PLANNER_BUFFER_POOL_SIZE) && // detect and set IDLE state
(cm.motion_state == MOTION_STOP) &&
(cm.hold_state == FEEDHOLD_OFF)) {
(cm->motion_state == MOTION_STOP) &&
(cm->hold_state == FEEDHOLD_OFF)) {
mp.planner_state = PLANNER_IDLE;
return (STAT_OK);
}
@@ -580,7 +580,7 @@ void mp_replan_queue(mpBuf_t *bf)
void mp_start_feed_override(const float ramp_time, const float override_factor)
{
cm.mfo_state = MFO_REQUESTED;
cm->mfo_state = MFO_REQUESTED;
if (mp.planner_state == PLANNER_IDLE) {
mp.mfo_factor = override_factor; // that was easy
@@ -817,11 +817,11 @@ void mp_commit_write_buffer(const blockType block_type)
q->w->block_state = BLOCK_INITIAL_ACTION;
if (block_type == BLOCK_TYPE_ALINE) {
if (cm.motion_state == MOTION_STOP) {
if (cm->motion_state == MOTION_STOP) {
cm_set_motion_state(MOTION_PLANNING);
}
} else {
if ((mp.planner_state > PLANNER_STARTUP) && (cm.hold_state == FEEDHOLD_OFF)) {
if ((mp.planner_state > PLANNER_STARTUP) && (cm->hold_state == FEEDHOLD_OFF)) {
// NB: BEWARE! the requested exec may result in the planner buffer being
// processed IMMEDIATELY and then freed - invalidating the contents
st_request_forward_plan(); // request an exec if the runtime is not busy
g2core/planner.h
+1 -1
View File
@@ -449,7 +449,7 @@ typedef struct mpMotionPlannerSingleton { // common variables for planning (mov
bool ramp_active; // true when a ramp is occurring
bool entry_changed; // mark if exit_velocity changed to invalidate next block's hint
// feed overrides and ramp variables (these extend the variables in cm.gmx)
// feed overrides and ramp variables (these extend the variables in cm->gmx)
float mfo_factor; // runtime override factor
float ramp_target;
float ramp_dvdt;
g2core/spindle.cpp
Executable → Regular
+2 -2
View File
@@ -228,7 +228,7 @@ static float _get_spindle_pwm (cmSpindleEnable enable, cmSpindleDir direction)
/*
stat_t cm_spindle_override_enable(uint8_t flag) // M51.1
{
if (fp_TRUE(cm.gf.parameter) && fp_ZERO(cm.gn.parameter)) {
if (fp_TRUE(cm->gf.parameter) && fp_ZERO(cm->gn.parameter)) {
spindle.override_enable = false;
} else {
spindle.override_enable = true;
@@ -239,7 +239,7 @@ stat_t cm_spindle_override_enable(uint8_t flag) // M51.1
stat_t cm_spindle_override_factor(uint8_t flag) // M50.1
{
spindle.override_enable = flag;
spindle.override_factor = cm.gn.parameter;
spindle.override_factor = cm->gn.parameter;
// change spindle speed
return (STAT_OK);
}
g2core/temperature.cpp
Executable → Regular
+1 -1
View File
@@ -523,7 +523,7 @@ const float kTempDiffSRTrigger = 0.25;
stat_t temperature_callback()
{
if (cm.machine_state == MACHINE_ALARM) {
if (cm->machine_state == MACHINE_ALARM) {
// Force the heaters off (redundant with the safety circuit)
fet_pin1 = 0.0;
fet_pin2 = 0.0;