From a4330f42ccab26c65b3b2dbede7689193ee24f89 Mon Sep 17 00:00:00 2001 From: Alden Hart Date: Fri, 9 Dec 2016 07:41:31 -0500 Subject: [PATCH] Intermediate commit - changing canonical machine struct to work by pointer - not absolute. Compiles. Does not run. --- g2core/canonical_machine.cpp | 520 ++++++++++++++++++----------------- g2core/canonical_machine.h | 27 +- g2core/config_app.cpp | 346 +++++++++++------------ g2core/controller.cpp | 26 +- g2core/cycle_homing.cpp | 108 ++++---- g2core/cycle_jogging.cpp | 18 +- g2core/cycle_probing.cpp | 68 ++--- g2core/gcode_parser.cpp | 76 ++--- g2core/gpio.cpp | 8 +- g2core/json_parser.cpp | 4 +- g2core/kinematics.cpp | 6 +- g2core/main.cpp | 3 +- g2core/persistence.cpp | 2 +- g2core/plan_arc.cpp | 44 +-- g2core/plan_exec.cpp | 50 ++-- g2core/plan_line.cpp | 58 ++-- g2core/planner.cpp | 12 +- g2core/planner.h | 2 +- g2core/spindle.cpp | 4 +- g2core/temperature.cpp | 2 +- 20 files changed, 704 insertions(+), 680 deletions(-) mode change 100755 => 100644 g2core/cycle_homing.cpp mode change 100755 => 100644 g2core/cycle_probing.cpp mode change 100755 => 100644 g2core/gpio.cpp mode change 100755 => 100644 g2core/json_parser.cpp mode change 100755 => 100644 g2core/kinematics.cpp mode change 100755 => 100644 g2core/main.cpp mode change 100755 => 100644 g2core/persistence.cpp mode change 100755 => 100644 g2core/spindle.cpp mode change 100755 => 100644 g2core/temperature.cpp diff --git a/g2core/canonical_machine.cpp b/g2core/canonical_machine.cpp index c285d9af..434102d1 100644 --- a/g2core/canonical_machine.cpp +++ b/g2core/canonical_machine.cpp @@ -112,7 +112,9 @@ **** STRUCTURE ALLOCATIONS ******************************************************** ***********************************************************************************/ -cmMachine_t cm; // canonical machine master structure +cmMachine_t *cm; // pointer to active canonical machine +cmMachine_t cm0; // canonical machine primary machine +cmMachine_t cm1; // canonical machine secondary machine /*********************************************************************************** **** GENERIC STATIC FUNCTIONS AND VARIABLES *************************************** @@ -141,7 +143,7 @@ static int8_t _get_axis_type(const index_t index); */ void cm_set_motion_state(const cmMotionState motion_state) { - cm.motion_state = motion_state; + cm->motion_state = motion_state; switch (motion_state) { case (MOTION_STOP): { ACTIVE_MODEL = MODEL; break; } @@ -158,11 +160,11 @@ void cm_set_motion_state(const cmMotionState motion_state) * cm_get_hold_state() * cm_get_homing_state() */ -cmMachineState cm_get_machine_state() { return cm.machine_state;} -cmCycleState cm_get_cycle_state() { return cm.cycle_state;} -cmMotionState cm_get_motion_state() { return cm.motion_state;} -cmFeedholdState cm_get_hold_state() { return cm.hold_state;} -cmHomingState cm_get_homing_state() { return cm.homing_state;} +cmMachineState cm_get_machine_state() { return cm->machine_state;} +cmCycleState cm_get_cycle_state() { return cm->cycle_state;} +cmMotionState cm_get_motion_state() { return cm->motion_state;} +cmFeedholdState cm_get_hold_state() { return cm->hold_state;} +cmHomingState cm_get_homing_state() { return cm->homing_state;} /* * cm_get_combined_state() - combines raw states into something a user might want to see @@ -177,20 +179,20 @@ cmHomingState cm_get_homing_state() { return cm.homing_state;} */ cmCombinedState cm_get_combined_state() { - if (cm.machine_state <= MACHINE_PROGRAM_END) { // replaces first 5 cm.machine_state cases - return ((cmCombinedState)cm.machine_state); //...where MACHINE_xxx == COMBINED_xxx + if (cm->machine_state <= MACHINE_PROGRAM_END) { // replaces first 5 cm->machine_state cases + return ((cmCombinedState)cm->machine_state); //...where MACHINE_xxx == COMBINED_xxx } - switch(cm.machine_state) { + switch(cm->machine_state) { case MACHINE_INTERLOCK: { return (COMBINED_INTERLOCK); } case MACHINE_SHUTDOWN: { return (COMBINED_SHUTDOWN); } case MACHINE_PANIC: { return (COMBINED_PANIC); } case MACHINE_CYCLE: { - switch(cm.cycle_state) { + switch(cm->cycle_state) { case CYCLE_HOMING: { return (COMBINED_HOMING); } case CYCLE_PROBE: { return (COMBINED_PROBE); } case CYCLE_JOG: { return (COMBINED_JOG); } case CYCLE_MACHINING: case CYCLE_OFF: { - switch(cm.motion_state) { + switch(cm->motion_state) { case MOTION_STOP: { return (COMBINED_RUN); } // See NOTE_1, above case MOTION_PLANNING: { return (COMBINED_RUN); } case MOTION_RUN: { return (COMBINED_RUN); } @@ -219,10 +221,10 @@ cmCombinedState cm_get_combined_state() ***********************************/ /* These getters and setters will work on any gm model with inputs: - * MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model + * MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model * PLANNER (GCodeState_t *)&bf->gm // relative to buffer *bf is currently pointing to * RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct - * ACTIVE_MODEL cm.am // active model pointer is maintained by state management + * ACTIVE_MODEL cm->am // active model pointer is maintained by state management */ uint32_t cm_get_linenum(const GCodeState_t *gcode_state) { return gcode_state->linenum;} cmMotionMode cm_get_motion_mode(const GCodeState_t *gcode_state) { return gcode_state->motion_mode;} @@ -234,7 +236,7 @@ uint8_t cm_get_distance_mode(const GCodeState_t *gcode_state) { return gcode_sta uint8_t cm_get_arc_distance_mode(const GCodeState_t *gcode_state) { return gcode_state->arc_distance_mode;} uint8_t cm_get_feed_rate_mode(const GCodeState_t *gcode_state) { return gcode_state->feed_rate_mode;} uint8_t cm_get_tool(const GCodeState_t *gcode_state) { return gcode_state->tool;} -uint8_t cm_get_block_delete_switch() { return cm.gmx.block_delete_switch;} +uint8_t cm_get_block_delete_switch() { return cm->gmx.block_delete_switch;} uint8_t cm_get_runtime_busy() { return (mp_get_runtime_busy());} float cm_get_feed_rate(const GCodeState_t *gcode_state) { return gcode_state->feed_rate;} @@ -256,7 +258,7 @@ void cm_set_absolute_override(GCodeState_t *gcode_state, const uint8_t absolute_ void cm_set_model_linenum(const uint32_t linenum) { - cm.gm.linenum = linenum; // you must first set the model line number, + cm->gm.linenum = linenum; // you must first set the model line number, nv_add_object((const char *)"n"); // then add the line number to the nv list } @@ -297,12 +299,12 @@ void cm_set_model_linenum(const uint32_t linenum) float cm_get_active_coord_offset(const uint8_t axis) { - if (cm.gm.absolute_override == ABSOLUTE_OVERRIDE_ON) { // no offset if in absolute override mode + if (cm->gm.absolute_override == ABSOLUTE_OVERRIDE_ON) { // no offset if in absolute override mode return (0.0); } - float offset = cm.offset[cm.gm.coord_system][axis]; - if (cm.gmx.origin_offset_enable == true) { - offset += cm.gmx.origin_offset[axis]; // includes G5x and G92 components + float offset = cm->offset[cm->gm.coord_system][axis]; + if (cm->gmx.origin_offset_enable == true) { + offset += cm->gmx.origin_offset[axis]; // includes G5x and G92 components } return (offset); } @@ -310,10 +312,10 @@ float cm_get_active_coord_offset(const uint8_t axis) /* * cm_get_work_offset() - return a coord offset from the gcode_state * - * MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model + * MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model * PLANNER (GCodeState_t *)&bf->gm // relative to buffer *bf is currently pointing to * RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct - * ACTIVE_MODEL cm.am // active model pointer is maintained by state management + * ACTIVE_MODEL cm->am // active model pointer is maintained by state management */ float cm_get_work_offset(const GCodeState_t *gcode_state, const uint8_t axis) @@ -324,10 +326,10 @@ float cm_get_work_offset(const GCodeState_t *gcode_state, const uint8_t axis) /* * cm_set_work_offsets() - capture coord offsets from the model into absolute values in the gcode_state * - * MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model + * MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model * PLANNER (GCodeState_t *)&bf->gm // relative to buffer *bf is currently pointing to * RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct - * ACTIVE_MODEL cm.am // active model pointer is maintained by state management + * ACTIVE_MODEL cm->am // active model pointer is maintained by state management */ void cm_set_work_offsets(GCodeState_t *gcode_state) @@ -341,7 +343,7 @@ void cm_set_work_offsets(GCodeState_t *gcode_state) * cm_get_absolute_position() - get position of axis in absolute coordinates * * This function accepts as input: - * MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model + * MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model * RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct * * NOTE: Only MODEL and RUNTIME are supported (no PLANNER or bf's) @@ -351,7 +353,7 @@ void cm_set_work_offsets(GCodeState_t *gcode_state) float cm_get_absolute_position(const GCodeState_t *gcode_state, const uint8_t axis) { if (gcode_state == MODEL) { - return (cm.gmx.position[axis]); + return (cm->gmx.position[axis]); } return (mp_get_runtime_absolute_position(axis)); } @@ -365,7 +367,7 @@ float cm_get_absolute_position(const GCodeState_t *gcode_state, const uint8_t ax * calling cm_get_model_coord_offset_vector() first. * * This function accepts as input: - * MODEL (GCodeState_t *)&cm.gm // absolute pointer from canonical machine gm model + * MODEL (GCodeState_t *)&cm->gm // absolute pointer from canonical machine gm model * RUNTIME (GCodeState_t *)&mr.gm // absolute pointer from runtime mm struct * * NOTE: Only MODEL and RUNTIME are supported (no PLANNER or bf's) @@ -376,7 +378,7 @@ float cm_get_work_position(const GCodeState_t *gcode_state, const uint8_t axis) float position; if (gcode_state == MODEL) { - position = cm.gmx.position[axis] - cm_get_active_coord_offset(axis); + position = cm->gmx.position[axis] - cm_get_active_coord_offset(axis); } else { position = mp_get_runtime_work_position(axis); } @@ -407,12 +409,12 @@ float cm_get_work_position(const GCodeState_t *gcode_state, const uint8_t axis) void cm_finalize_move() { - copy_vector(cm.gmx.position, cm.gm.target); // update model position + copy_vector(cm->gmx.position, cm->gm.target); // update model position } void cm_update_model_position_from_runtime() { - copy_vector(cm.gmx.position, mr.gm.target); + copy_vector(cm->gmx.position, mr.gm.target); } /* @@ -424,14 +426,14 @@ void cm_update_model_position_from_runtime() stat_t cm_deferred_write_callback() { - if ((cm.cycle_state == CYCLE_OFF) && (cm.deferred_write_flag == true)) { - cm.deferred_write_flag = false; + if ((cm->cycle_state == CYCLE_OFF) && (cm->deferred_write_flag == true)) { + cm->deferred_write_flag = false; nvObj_t nv; for (uint8_t i=1; i<=COORDS; i++) { for (uint8_t j=0; joffset[i][j]; nv_persist(&nv); // Note: only writes values that have changed } } @@ -461,9 +463,9 @@ stat_t cm_set_tram(nvObj_t *nv) } // check to make sure we have three valid probes in a row - if ((cm.probe_state[0] == PROBE_SUCCEEDED) && - (cm.probe_state[1] == PROBE_SUCCEEDED) && - (cm.probe_state[2] == PROBE_SUCCEEDED)) + if ((cm->probe_state[0] == PROBE_SUCCEEDED) && + (cm->probe_state[1] == PROBE_SUCCEEDED) && + (cm->probe_state[2] == PROBE_SUCCEEDED)) { // Step 1: Get the normal of the plane formed by the three probes @@ -473,12 +475,12 @@ stat_t cm_set_tram(nvObj_t *nv) // n_{xyz} is the unit normal // Step 1a: get the deltas - float d0_x = cm.probe_results[0][0] - cm.probe_results[1][0]; - float d0_y = cm.probe_results[0][1] - cm.probe_results[1][1]; - float d0_z = cm.probe_results[0][2] - cm.probe_results[1][2]; - float d2_x = cm.probe_results[2][0] - cm.probe_results[1][0]; - float d2_y = cm.probe_results[2][1] - cm.probe_results[1][1]; - float d2_z = cm.probe_results[2][2] - cm.probe_results[1][2]; + float d0_x = cm->probe_results[0][0] - cm->probe_results[1][0]; + float d0_y = cm->probe_results[0][1] - cm->probe_results[1][1]; + float d0_z = cm->probe_results[0][2] - cm->probe_results[1][2]; + float d2_x = cm->probe_results[2][0] - cm->probe_results[1][0]; + float d2_y = cm->probe_results[2][1] - cm->probe_results[1][1]; + float d2_z = cm->probe_results[2][2] - cm->probe_results[1][2]; // Step 1b: compute the combined magnitde // since sqrt(a)*sqrt(b) = sqrt(a*b), we can save a sqrt in making the unit normal @@ -522,20 +524,22 @@ stat_t cm_set_tram(nvObj_t *nv) {0, 0, 0, 1} } */ - cm.rotation_matrix[0][0] = 1 - q_yy_2; - cm.rotation_matrix[0][1] = q_xy_2; - cm.rotation_matrix[0][2] = q_wy_2; + cm->rotation_matrix[0][0] = 1 - q_yy_2; + cm->rotation_matrix[0][1] = q_xy_2; + cm->rotation_matrix[0][2] = q_wy_2; - cm.rotation_matrix[1][0] = q_xy_2; - cm.rotation_matrix[1][1] = 1 - q_xx_2; - cm.rotation_matrix[1][2] = -q_wx_2; + cm->rotation_matrix[1][0] = q_xy_2; + cm->rotation_matrix[1][1] = 1 - q_xx_2; + cm->rotation_matrix[1][2] = -q_wx_2; - cm.rotation_matrix[2][0] = -q_wy_2; - cm.rotation_matrix[2][1] = q_wx_2; - cm.rotation_matrix[2][2] = 1 - q_xx_2 - q_yy_2; + cm->rotation_matrix[2][0] = -q_wy_2; + cm->rotation_matrix[2][1] = q_wx_2; + cm->rotation_matrix[2][2] = 1 - q_xx_2 - q_yy_2; // Step 4: compute the z-offset - cm.rotation_z_offset = (n_x*cm.probe_results[1][0] + n_y*cm.probe_results[1][1]) / n_z + cm.probe_results[1][2]; + cm->rotation_z_offset = (n_x*cm->probe_results[1][0] + + n_y*cm->probe_results[1][1]) / + n_z + cm->probe_results[1][2]; } else { return (STAT_COMMAND_NOT_ACCEPTED); } @@ -552,16 +556,16 @@ stat_t cm_get_tram(nvObj_t *nv) { nv->value = true; - if (fp_NOT_ZERO(cm.rotation_z_offset) || - fp_NOT_ZERO(cm.rotation_matrix[0][1]) || - fp_NOT_ZERO(cm.rotation_matrix[0][2]) || - fp_NOT_ZERO(cm.rotation_matrix[1][0]) || - fp_NOT_ZERO(cm.rotation_matrix[1][2]) || - fp_NOT_ZERO(cm.rotation_matrix[2][0]) || - fp_NOT_ZERO(cm.rotation_matrix[2][1]) || - fp_NE(1.0, cm.rotation_matrix[0][0]) || - fp_NE(1.0, cm.rotation_matrix[1][1]) || - fp_NE(1.0, cm.rotation_matrix[2][2])) + if (fp_NOT_ZERO(cm->rotation_z_offset) || + fp_NOT_ZERO(cm->rotation_matrix[0][1]) || + fp_NOT_ZERO(cm->rotation_matrix[0][2]) || + fp_NOT_ZERO(cm->rotation_matrix[1][0]) || + fp_NOT_ZERO(cm->rotation_matrix[1][2]) || + fp_NOT_ZERO(cm->rotation_matrix[2][0]) || + fp_NOT_ZERO(cm->rotation_matrix[2][1]) || + fp_NE(1.0, cm->rotation_matrix[0][0]) || + fp_NE(1.0, cm->rotation_matrix[1][1]) || + fp_NE(1.0, cm->rotation_matrix[2][2])) { nv->value = false; @@ -598,10 +602,10 @@ stat_t cm_get_tram(nvObj_t *nv) static float _calc_ABC(const uint8_t axis, const float target[]) { - if ((cm.a[axis].axis_mode == AXIS_STANDARD) || (cm.a[axis].axis_mode == AXIS_INHIBITED)) { + if ((cm->a[axis].axis_mode == AXIS_STANDARD) || (cm->a[axis].axis_mode == AXIS_INHIBITED)) { return(target[axis]); // no mm conversion - it's in degrees } - return(_to_millimeters(target[axis]) * 360 / (2 * M_PI * cm.a[axis].radius)); + return(_to_millimeters(target[axis]) * 360 / (2 * M_PI * cm->a[axis].radius)); } void cm_set_model_target(const float target[], const bool flags[]) @@ -610,31 +614,31 @@ void cm_set_model_target(const float target[], const bool flags[]) float tmp = 0; // copy position to target so it always starts correctly - copy_vector(cm.gm.target, cm.gmx.position); + copy_vector(cm->gm.target, cm->gmx.position); // process XYZABC for lower modes for (axis=AXIS_X; axis<=AXIS_Z; axis++) { - if (!flags[axis] || cm.a[axis].axis_mode == AXIS_DISABLED) { + if (!flags[axis] || cm->a[axis].axis_mode == AXIS_DISABLED) { continue; // skip axis if not flagged for update or its disabled - } else if ((cm.a[axis].axis_mode == AXIS_STANDARD) || (cm.a[axis].axis_mode == AXIS_INHIBITED)) { - if (cm.gm.distance_mode == ABSOLUTE_MODE) { - cm.gm.target[axis] = cm_get_active_coord_offset(axis) + _to_millimeters(target[axis]); + } else if ((cm->a[axis].axis_mode == AXIS_STANDARD) || (cm->a[axis].axis_mode == AXIS_INHIBITED)) { + if (cm->gm.distance_mode == ABSOLUTE_MODE) { + cm->gm.target[axis] = cm_get_active_coord_offset(axis) + _to_millimeters(target[axis]); } else { - cm.gm.target[axis] += _to_millimeters(target[axis]); + cm->gm.target[axis] += _to_millimeters(target[axis]); } } } // FYI: The ABC loop below relies on the XYZ loop having been run first for (axis=AXIS_A; axis<=AXIS_C; axis++) { - if (!flags[axis] || cm.a[axis].axis_mode == AXIS_DISABLED) { + if (!flags[axis] || cm->a[axis].axis_mode == AXIS_DISABLED) { continue; // skip axis if not flagged for update or its disabled } else { tmp = _calc_ABC(axis, target); } - if (cm.gm.distance_mode == ABSOLUTE_MODE) { - cm.gm.target[axis] = tmp + cm_get_active_coord_offset(axis); // sacidu93's fix to Issue #22 + if (cm->gm.distance_mode == ABSOLUTE_MODE) { + cm->gm.target[axis] = tmp + cm_get_active_coord_offset(axis); // sacidu93's fix to Issue #22 } else { - cm.gm.target[axis] += tmp; + cm->gm.target[axis] += tmp; } } } @@ -652,24 +656,24 @@ void cm_set_model_target(const float target[], const bool flags[]) static stat_t _finalize_soft_limits(const stat_t status) { - cm.gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE; // cancel motion - copy_vector(cm.gm.target, cm.gmx.position); // reset model target + cm->gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE; // cancel motion + copy_vector(cm->gm.target, cm->gmx.position); // reset model target return (cm_alarm(status, "soft_limits")); // throw an alarm } stat_t cm_test_soft_limits(const float target[]) { - if (cm.soft_limit_enable == true) { + if (cm->soft_limit_enable == true) { for (uint8_t axis = AXIS_X; axis < AXES; axis++) { - if (cm.homed[axis] != true) { continue; } // skip axis if not homed - if (fp_EQ(cm.a[axis].travel_min, cm.a[axis].travel_max)) { continue; } // skip axis if identical - if (fabs(cm.a[axis].travel_min) > DISABLE_SOFT_LIMIT) { continue; } // skip min test if disabled - if (fabs(cm.a[axis].travel_max) > DISABLE_SOFT_LIMIT) { continue; } // skip max test if disabled + if (cm->homed[axis] != true) { continue; } // skip axis if not homed + if (fp_EQ(cm->a[axis].travel_min, cm->a[axis].travel_max)) { continue; } // skip axis if identical + if (fabs(cm->a[axis].travel_min) > DISABLE_SOFT_LIMIT) { continue; } // skip min test if disabled + if (fabs(cm->a[axis].travel_max) > DISABLE_SOFT_LIMIT) { continue; } // skip max test if disabled - if (target[axis] < cm.a[axis].travel_min) { + if (target[axis] < cm->a[axis].travel_min) { return (_finalize_soft_limits(STAT_SOFT_LIMIT_EXCEEDED_XMIN + 2*axis)); } - if (target[axis] > cm.a[axis].travel_max) { + if (target[axis] > cm->a[axis].travel_max) { return (_finalize_soft_limits(STAT_SOFT_LIMIT_EXCEEDED_XMAX + 2*axis)); } } @@ -697,11 +701,12 @@ stat_t cm_test_soft_limits(const float target[]) void canonical_machine_init() { -// If you can assume all memory has been zeroed by a hard reset you don't need this code: - memset(&cm, 0, sizeof(cm)); // do not reset canonicalMachineSingleton once it's been initialized - memset(&cm.gm, 0, sizeof(GCodeState_t)); // clear all values, pointers and status - memset(&cm.gn, 0, sizeof(GCodeInput_t)); - memset(&cm.gf, 0, sizeof(GCodeFlags_t)); + // If you can assume all memory has been zeroed by a hard reset you don't need this code: +// memset(&cm, 0, sizeof(cm)); // do not reset canonicalMachineSingleton once it's been initialized + memset(cm, 0, sizeof(cm0)); // do not reset canonicalMachineSingleton once it's been initialized + memset(&cm->gm, 0, sizeof(GCodeState_t)); // clear all values, pointers and status + memset(&cm->gn, 0, sizeof(GCodeInput_t)); + memset(&cm->gf, 0, sizeof(GCodeFlags_t)); canonical_machine_init_assertions(); // establish assertions ACTIVE_MODEL = MODEL; // setup initial Gcode model pointer @@ -709,22 +714,22 @@ void canonical_machine_init() } void canonical_machine_reset_rotation() { - memset(&cm.rotation_matrix, 0, sizeof(float)*3*3); + memset(&cm->rotation_matrix, 0, sizeof(float)*3*3); // We must make it an identity matrix for no rotation - cm.rotation_matrix[0][0] = 1.0; - cm.rotation_matrix[1][1] = 1.0; - cm.rotation_matrix[2][2] = 1.0; - cm.rotation_z_offset = 0.0; + cm->rotation_matrix[0][0] = 1.0; + cm->rotation_matrix[1][1] = 1.0; + cm->rotation_matrix[2][2] = 1.0; + cm->rotation_z_offset = 0.0; } void canonical_machine_reset() { // set gcode defaults - cm_set_units_mode(cm.default_units_mode); - cm_set_coord_system(cm.default_coord_system); // NB: queues a block to the planner with the coordinates - cm_select_plane(cm.default_select_plane); - cm_set_path_control(MODEL, cm.default_path_control); - cm_set_distance_mode(cm.default_distance_mode); + cm_set_units_mode(cm->default_units_mode); + cm_set_coord_system(cm->default_coord_system); // NB: queues a block to the planner with the coordinates + cm_select_plane(cm->default_select_plane); + cm_set_path_control(MODEL, cm->default_path_control); + cm_set_distance_mode(cm->default_distance_mode); cm_set_arc_distance_mode(INCREMENTAL_MODE); // always the default cm_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); // always the default cm_reset_overrides(); // set overrides to initial conditions @@ -732,26 +737,26 @@ void canonical_machine_reset() // NOTE: Should unhome axes here // reset request flags - cm.queue_flush_state = FLUSH_OFF; - cm.end_hold_requested = false; - cm.limit_requested = 0; // resets switch closures that occurred during initialization - cm.safety_interlock_disengaged = 0; // ditto - cm.safety_interlock_reengaged = 0; // ditto - cm.shutdown_requested = 0; // ditto + cm->queue_flush_state = FLUSH_OFF; + cm->end_hold_requested = false; + cm->limit_requested = 0; // resets switch closures that occurred during initialization + cm->safety_interlock_disengaged = 0; // ditto + cm->safety_interlock_reengaged = 0; // ditto + cm->shutdown_requested = 0; // ditto // set initial state and signal that the machine is ready for action - cm.cycle_state = CYCLE_OFF; - cm.motion_state = MOTION_STOP; - cm.hold_state = FEEDHOLD_OFF; - cm.esc_boot_timer = SysTickTimer_getValue(); - cm.gmx.block_delete_switch = true; - cm.gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE; // never start in a motion mode - cm.machine_state = MACHINE_READY; + cm->cycle_state = CYCLE_OFF; + cm->motion_state = MOTION_STOP; + cm->hold_state = FEEDHOLD_OFF; + cm->esc_boot_timer = SysTickTimer_getValue(); + cm->gmx.block_delete_switch = true; + cm->gm.motion_mode = MOTION_MODE_CANCEL_MOTION_MODE; // never start in a motion mode + cm->machine_state = MACHINE_READY; canonical_machine_reset_rotation(); - memset(&cm.probe_state, 0, sizeof(cmProbeState)*PROBES_STORED); - memset(&cm.probe_results, 0, sizeof(float)*PROBES_STORED*AXES); + memset(&cm->probe_state, 0, sizeof(cmProbeState)*PROBES_STORED); + memset(&cm->probe_results, 0, sizeof(float)*PROBES_STORED*AXES); } /* @@ -761,18 +766,18 @@ void canonical_machine_reset() void canonical_machine_init_assertions(void) { - cm.magic_start = MAGICNUM; - cm.magic_end = MAGICNUM; - cm.gmx.magic_start = MAGICNUM; - cm.gmx.magic_end = MAGICNUM; + cm->magic_start = MAGICNUM; + cm->magic_end = MAGICNUM; + cm->gmx.magic_start = MAGICNUM; + cm->gmx.magic_end = MAGICNUM; arc.magic_start = MAGICNUM; arc.magic_end = MAGICNUM; } stat_t canonical_machine_test_assertions(void) { - if ((BAD_MAGIC(cm.magic_start)) || (BAD_MAGIC(cm.magic_end)) || - (BAD_MAGIC(cm.gmx.magic_start)) || (BAD_MAGIC(cm.gmx.magic_end)) || + if ((BAD_MAGIC(cm->magic_start)) || (BAD_MAGIC(cm->magic_end)) || + (BAD_MAGIC(cm->gmx.magic_start)) || (BAD_MAGIC(cm->gmx.magic_end)) || (BAD_MAGIC(arc.magic_start)) || (BAD_MAGIC(arc.magic_end))) { return(cm_panic(STAT_CANONICAL_MACHINE_ASSERTION_FAILURE, "canonical_machine_test_assertions()")); } @@ -827,16 +832,16 @@ stat_t cm_clr(nvObj_t *nv) // clear alarm or shutdown from comman void cm_clear() { - if (cm.machine_state == MACHINE_ALARM) { - cm.machine_state = MACHINE_PROGRAM_STOP; - } else if (cm.machine_state == MACHINE_SHUTDOWN) { - cm.machine_state = MACHINE_READY; + if (cm->machine_state == MACHINE_ALARM) { + cm->machine_state = MACHINE_PROGRAM_STOP; + } else if (cm->machine_state == MACHINE_SHUTDOWN) { + cm->machine_state = MACHINE_READY; } } void cm_parse_clear(const char *s) { - if (cm.machine_state == MACHINE_ALARM) { + if (cm->machine_state == MACHINE_ALARM) { if (toupper(s[0]) == 'M') { if (( (s[1]=='3') && (s[2]=='0') && (s[3]==NUL)) || ((s[1]=='2') && (s[2]==NUL) )) { cm_clear(); @@ -851,9 +856,9 @@ void cm_parse_clear(const char *s) stat_t cm_is_alarmed() { - if (cm.machine_state == MACHINE_ALARM) { return (STAT_COMMAND_REJECTED_BY_ALARM); } - if (cm.machine_state == MACHINE_SHUTDOWN) { return (STAT_COMMAND_REJECTED_BY_SHUTDOWN); } - if (cm.machine_state == MACHINE_PANIC) { return (STAT_COMMAND_REJECTED_BY_PANIC); } + if (cm->machine_state == MACHINE_ALARM) { return (STAT_COMMAND_REJECTED_BY_ALARM); } + if (cm->machine_state == MACHINE_SHUTDOWN) { return (STAT_COMMAND_REJECTED_BY_SHUTDOWN); } + if (cm->machine_state == MACHINE_PANIC) { return (STAT_COMMAND_REJECTED_BY_PANIC); } return (STAT_OK); } @@ -877,9 +882,9 @@ void cm_halt_motion(void) { mp_halt_runtime(); // stop the runtime. Do this immediately. (Reset is in cm_clear) canonical_machine_reset(); // reset Gcode model - cm.cycle_state = CYCLE_OFF; // Note: leaves machine_state alone - cm.motion_state = MOTION_STOP; - cm.hold_state = FEEDHOLD_OFF; + cm->cycle_state = CYCLE_OFF; // Note: leaves machine_state alone + cm->motion_state = MOTION_STOP; + cm->hold_state = FEEDHOLD_OFF; } /* @@ -907,11 +912,11 @@ void cm_halt_motion(void) stat_t cm_alarm(const stat_t status, const char *msg) { - if ((cm.machine_state == MACHINE_ALARM) || (cm.machine_state == MACHINE_SHUTDOWN) || - (cm.machine_state == MACHINE_PANIC)) { + if ((cm->machine_state == MACHINE_ALARM) || (cm->machine_state == MACHINE_SHUTDOWN) || + (cm->machine_state == MACHINE_PANIC)) { return (STAT_OK); // don't alarm if already in an alarm state } - cm.machine_state = MACHINE_ALARM; + cm->machine_state = MACHINE_ALARM; cm_request_feedhold(); // stop motion cm_request_queue_flush(); // do a queue flush once runtime is not busy @@ -945,7 +950,7 @@ stat_t cm_alarm(const stat_t status, const char *msg) stat_t cm_shutdown(const stat_t status, const char *msg) { - if ((cm.machine_state == MACHINE_SHUTDOWN) || (cm.machine_state == MACHINE_PANIC)) { + if ((cm->machine_state == MACHINE_SHUTDOWN) || (cm->machine_state == MACHINE_PANIC)) { return (STAT_OK); // don't shutdown if shutdown or panic'd } cm_halt_motion(); // halt motors (may have already been done from GPIO) @@ -955,11 +960,11 @@ stat_t cm_shutdown(const stat_t status, const char *msg) cm_queue_flush(); // flush all queues and reset positions for (uint8_t i = 0; i < HOMING_AXES; i++) { // unhome axes and the machine - cm.homed[i] = false; + cm->homed[i] = false; } - cm.homing_state = HOMING_NOT_HOMED; + cm->homing_state = HOMING_NOT_HOMED; - cm.machine_state = MACHINE_SHUTDOWN; // do this after all other activity + cm->machine_state = MACHINE_SHUTDOWN; // do this after all other activity rpt_exception(status, msg); // send exception report return (status); } @@ -978,7 +983,7 @@ stat_t cm_panic(const stat_t status, const char *msg) { _debug_trap(msg); - if (cm.machine_state == MACHINE_PANIC) { // only do this once + if (cm->machine_state == MACHINE_PANIC) { // only do this once return (STAT_OK); } cm_halt_motion(); // halt motors (may have already been done from GPIO) @@ -987,7 +992,7 @@ stat_t cm_panic(const stat_t status, const char *msg) temperature_reset(); // turn off heaters and fans cm_queue_flush(); // flush all queues and reset positions - cm.machine_state = MACHINE_PANIC; // don't reset anything. Panics are not recoverable + cm->machine_state = MACHINE_PANIC; // don't reset anything. Panics are not recoverable rpt_exception(status, msg); // send panic report return (status); } @@ -1010,25 +1015,25 @@ stat_t cm_panic(const stat_t status, const char *msg) stat_t cm_select_plane(const uint8_t plane) { - cm.gm.select_plane = (cmCanonicalPlane)plane; + cm->gm.select_plane = (cmCanonicalPlane)plane; return (STAT_OK); } stat_t cm_set_units_mode(const uint8_t mode) { - cm.gm.units_mode = (cmUnitsMode)mode; // 0 = inches, 1 = mm. + cm->gm.units_mode = (cmUnitsMode)mode; // 0 = inches, 1 = mm. return(STAT_OK); } stat_t cm_set_distance_mode(const uint8_t mode) { - cm.gm.distance_mode = (cmDistanceMode)mode; // 0 = absolute mode, 1 = incremental + cm->gm.distance_mode = (cmDistanceMode)mode; // 0 = absolute mode, 1 = incremental return (STAT_OK); } stat_t cm_set_arc_distance_mode(const uint8_t mode) { - cm.gm.arc_distance_mode = (cmDistanceMode)mode; // 0 = absolute mode, 1 = incremental + cm->gm.arc_distance_mode = (cmDistanceMode)mode; // 0 = absolute mode, 1 = incremental return (STAT_OK); } @@ -1050,7 +1055,7 @@ stat_t cm_set_coord_offsets(const uint8_t coord_system, if ((coord_system < G54) || (coord_system > COORD_SYSTEM_MAX)) { // you can't set G53 return (STAT_P_WORD_IS_INVALID); } - if (!cm.gf.L_word) { + if (!cm->gf.L_word) { return (STAT_L_WORD_IS_MISSING); } if ((L_word != 2) && (L_word != 20)) { @@ -1059,11 +1064,11 @@ stat_t cm_set_coord_offsets(const uint8_t coord_system, for (uint8_t axis = AXIS_X; axis < AXES; axis++) { if (flag[axis]) { if (L_word == 2) { - cm.offset[coord_system][axis] = _to_millimeters(offset[axis]); + cm->offset[coord_system][axis] = _to_millimeters(offset[axis]); } else { - cm.offset[coord_system][axis] = cm.gmx.position[axis] - _to_millimeters(offset[axis]); + cm->offset[coord_system][axis] = cm->gmx.position[axis] - _to_millimeters(offset[axis]); } - cm.deferred_write_flag = true; // persist offsets once machining cycle is over + cm->deferred_write_flag = true; // persist offsets once machining cycle is over } } return (STAT_OK); @@ -1078,7 +1083,7 @@ stat_t cm_set_coord_offsets(const uint8_t coord_system, */ stat_t cm_set_coord_system(const uint8_t coord_system) { - cm.gm.coord_system = (cmCoordSystem)coord_system; + cm->gm.coord_system = (cmCoordSystem)coord_system; float value[] = { (float)coord_system,0,0,0,0,0 }; // pass coordinate system in value[0] element bool flags[] = { 1,0,0,0,0,0 }; @@ -1091,7 +1096,7 @@ static void _exec_offset(float *value, bool *flag) uint8_t coord_system = ((uint8_t)value[0]); // coordinate system is passed in value[0] element float offsets[AXES]; for (uint8_t axis = AXIS_X; axis < AXES; axis++) { - offsets[axis] = cm.offset[coord_system][axis] + (cm.gmx.origin_offset[axis] * cm.gmx.origin_offset_enable); + offsets[axis] = cm->offset[coord_system][axis] + (cm->gmx.origin_offset[axis] * cm->gmx.origin_offset_enable); } mp_set_runtime_work_offset(offsets); cm_set_work_offsets(MODEL); // set work offsets in the Gcode model @@ -1119,8 +1124,8 @@ static void _exec_offset(float *value, bool *flag) void cm_set_position(const uint8_t axis, const float position) { // TODO: Interlock involving runtime_busy test - cm.gmx.position[axis] = position; - cm.gm.target[axis] = position; + cm->gmx.position[axis] = position; + cm->gm.target[axis] = position; mp_set_planner_position(axis, position); mp_set_runtime_position(axis, position); mp_set_steps_to_runtime_position(); @@ -1146,10 +1151,10 @@ stat_t cm_set_absolute_origin(const float origin[], bool flag[]) for (uint8_t axis = AXIS_X; axis < AXES; axis++) { if (flag[axis]) { -// REMOVED value[axis] = cm.offset[cm.gm.coord_system][axis] + _to_millimeters(origin[axis]); // G2 Issue #26 +// REMOVED value[axis] = cm->offset[cm->gm.coord_system][axis] + _to_millimeters(origin[axis]); // G2 Issue #26 value[axis] = _to_millimeters(origin[axis]); - cm.gmx.position[axis] = value[axis]; // set model position - cm.gm.target[axis] = value[axis]; // reset model target + cm->gmx.position[axis] = value[axis]; // set model position + cm->gm.target[axis] = value[axis]; // reset model target mp_set_planner_position(axis, value[axis]); // set mm position } } @@ -1162,7 +1167,7 @@ static void _exec_absolute_origin(float *value, bool *flag) for (uint8_t axis = AXIS_X; axis < AXES; axis++) { if (flag[axis]) { mp_set_runtime_position(axis, value[axis]); - cm.homed[axis] = true; // G28.3 is not considered homed until you get here + cm->homed[axis] = true; // G28.3 is not considered homed until you get here } } mp_set_steps_to_runtime_position(); @@ -1181,15 +1186,15 @@ static void _exec_absolute_origin(float *value, bool *flag) stat_t cm_set_origin_offsets(const float offset[], const bool flag[]) { // set offsets in the Gcode model extended context - cm.gmx.origin_offset_enable = true; + cm->gmx.origin_offset_enable = true; for (uint8_t axis = AXIS_X; axis < AXES; axis++) { if (flag[axis]) { - cm.gmx.origin_offset[axis] = cm.gmx.position[axis] - - cm.offset[cm.gm.coord_system][axis] - _to_millimeters(offset[axis]); + cm->gmx.origin_offset[axis] = cm->gmx.position[axis] - + cm->offset[cm->gm.coord_system][axis] - _to_millimeters(offset[axis]); } } // now pass the offset to the callback - setting the coordinate system also applies the offsets - float value[] = { (float)cm.gm.coord_system,0,0,0,0,0 }; // pass coordinate system in value[0] element + float value[] = { (float)cm->gm.coord_system,0,0,0,0,0 }; // pass coordinate system in value[0] element bool flags[] = { 1,0,0,0,0,0 }; mp_queue_command(_exec_offset, value, flags); return (STAT_OK); @@ -1197,11 +1202,11 @@ stat_t cm_set_origin_offsets(const float offset[], const bool flag[]) stat_t cm_reset_origin_offsets() { - cm.gmx.origin_offset_enable = false; + cm->gmx.origin_offset_enable = false; for (uint8_t axis = AXIS_X; axis < AXES; axis++) { - cm.gmx.origin_offset[axis] = 0; + cm->gmx.origin_offset[axis] = 0; } - float value[] = { (float)cm.gm.coord_system,0,0,0,0,0 }; + float value[] = { (float)cm->gm.coord_system,0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; mp_queue_command(_exec_offset, value, flags); return (STAT_OK); @@ -1209,8 +1214,8 @@ stat_t cm_reset_origin_offsets() stat_t cm_suspend_origin_offsets() { - cm.gmx.origin_offset_enable = false; - float value[] = { (float)cm.gm.coord_system,0,0,0,0,0 }; + cm->gmx.origin_offset_enable = false; + float value[] = { (float)cm->gm.coord_system,0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; mp_queue_command(_exec_offset, value, flags); return (STAT_OK); @@ -1218,8 +1223,8 @@ stat_t cm_suspend_origin_offsets() stat_t cm_resume_origin_offsets() { - cm.gmx.origin_offset_enable = true; - float value[] = { (float)cm.gm.coord_system,0,0,0,0,0 }; + cm->gmx.origin_offset_enable = true; + float value[] = { (float)cm->gm.coord_system,0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; mp_queue_command(_exec_offset, value, flags); return (STAT_OK); @@ -1234,7 +1239,7 @@ stat_t cm_resume_origin_offsets() stat_t cm_straight_traverse(const float target[], const bool flags[]) { - cm.gm.motion_mode = MOTION_MODE_STRAIGHT_TRAVERSE; + cm->gm.motion_mode = MOTION_MODE_STRAIGHT_TRAVERSE; // it's legal for a G0 to have no axis words but we don't want to process it if (!(flags[AXIS_X] || flags[AXIS_Y] || flags[AXIS_Z] || @@ -1243,10 +1248,10 @@ stat_t cm_straight_traverse(const float target[], const bool flags[]) } cm_set_model_target(target, flags); - ritorno (cm_test_soft_limits(cm.gm.target)); // test soft limits; exit if thrown - cm_set_work_offsets(&cm.gm); // capture the fully resolved offsets to the state + ritorno (cm_test_soft_limits(cm->gm.target)); // test soft limits; exit if thrown + cm_set_work_offsets(&cm->gm); // capture the fully resolved offsets to the state cm_cycle_start(); // required for homing & other cycles - stat_t status = mp_aline(&cm.gm); // send the move to the planner + stat_t status = mp_aline(&cm->gm); // send the move to the planner cm_finalize_move(); if (status == STAT_MINIMUM_LENGTH_MOVE && !mp_has_runnable_buffer(ACTIVE_Q)) { cm_cycle_end(); @@ -1267,12 +1272,12 @@ stat_t _goto_stored_position(float target2[], const float target[], const bool f cm_straight_traverse(target, flags); // Go through intermediate point if provided cm_set_absolute_override(MODEL, ABSOLUTE_OVERRIDE_ON);// Position was stored in absolute coords - if (cm.gm.units_mode == INCHES) { // If G28 or G30 are called while in inches mode + if (cm->gm.units_mode == INCHES) { // If G28 or G30 are called while in inches mode for (uint8_t i=0; igm.distance_mode == INCREMENTAL_MODE) { // Subtract out any movement already performed for (uint8_t i=0; igmx.g28_position, cm->gmx.position); // in MM and machine coordinates return (STAT_OK); } stat_t cm_goto_g28_position(const float target[], const bool flags[]) { - return (_goto_stored_position(cm.gmx.g28_position, target, flags)); + return (_goto_stored_position(cm->gmx.g28_position, target, flags)); } stat_t cm_set_g30_position(void) { - copy_vector(cm.gmx.g30_position, cm.gmx.position); // in MM and machine coordinates + copy_vector(cm->gmx.g30_position, cm->gmx.position); // in MM and machine coordinates return (STAT_OK); } stat_t cm_goto_g30_position(const float target[], const bool flags[]) { - return (_goto_stored_position(cm.gmx.g30_position, target, flags)); + return (_goto_stored_position(cm->gmx.g30_position, target, flags)); } /******************************** @@ -1316,13 +1321,13 @@ stat_t cm_goto_g30_position(const float target[], const bool flags[]) stat_t cm_set_feed_rate(const float feed_rate) { - if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE) { + if (cm->gm.feed_rate_mode == INVERSE_TIME_MODE) { if (fp_ZERO(feed_rate)) { return (STAT_GCODE_FEEDRATE_NOT_SPECIFIED); } - cm.gm.feed_rate = 1/feed_rate; // normalize to minutes (NB: active for this gcode block only) + cm->gm.feed_rate = 1/feed_rate; // normalize to minutes (NB: active for this gcode block only) } else { - cm.gm.feed_rate = _to_millimeters(feed_rate); + cm->gm.feed_rate = _to_millimeters(feed_rate); } return (STAT_OK); } @@ -1337,7 +1342,7 @@ stat_t cm_set_feed_rate(const float feed_rate) stat_t cm_set_feed_rate_mode(const uint8_t mode) { - cm.gm.feed_rate_mode = (cmFeedRateMode)mode; + cm->gm.feed_rate_mode = (cmFeedRateMode)mode; return (STAT_OK); } @@ -1365,7 +1370,7 @@ stat_t cm_set_path_control(GCodeState_t *gcode_state, const uint8_t mode) */ stat_t cm_dwell(const float seconds) { - cm.gm.parameter = seconds; + cm->gm.parameter = seconds; mp_dwell(seconds); return (STAT_OK); } @@ -1376,10 +1381,10 @@ stat_t cm_dwell(const float seconds) stat_t cm_straight_feed(const float target[], const bool flags[]) { // 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); } - cm.gm.motion_mode = MOTION_MODE_STRAIGHT_FEED; + cm->gm.motion_mode = MOTION_MODE_STRAIGHT_FEED; // it's legal for a G1 to have no axis words but we don't want to process it if (!(flags[AXIS_X] || flags[AXIS_Y] || flags[AXIS_Z] || @@ -1388,10 +1393,10 @@ stat_t cm_straight_feed(const float target[], const bool flags[]) } cm_set_model_target(target, flags); - ritorno (cm_test_soft_limits(cm.gm.target)); // test soft limits; exit if thrown - cm_set_work_offsets(&cm.gm); // capture the fully resolved offsets to the state + ritorno (cm_test_soft_limits(cm->gm.target)); // test soft limits; exit if thrown + cm_set_work_offsets(&cm->gm); // capture the fully resolved offsets to the state cm_cycle_start(); // required for homing & other cycles - stat_t status = mp_aline(&cm.gm); // send the move to the planner + stat_t status = mp_aline(&cm->gm); // send the move to the planner cm_finalize_move(); // <-- ONLY safe because we don't care about status... @@ -1430,12 +1435,12 @@ stat_t cm_select_tool(const uint8_t tool_select) static void _exec_select_tool(float *value, bool *flag) { - cm.gm.tool_select = (uint8_t)value[0]; + cm->gm.tool_select = (uint8_t)value[0]; } stat_t cm_change_tool(const uint8_t tool_change) { - float value[] = { (float)cm.gm.tool_select,0,0,0,0,0 }; + float value[] = { (float)cm->gm.tool_select,0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; mp_queue_command(_exec_change_tool, value, flags); return (STAT_OK); @@ -1443,7 +1448,7 @@ stat_t cm_change_tool(const uint8_t tool_change) static void _exec_change_tool(float *value, bool *flag) { - cm.gm.tool = (uint8_t)value[0]; + cm->gm.tool = (uint8_t)value[0]; } /*********************************** @@ -1466,11 +1471,11 @@ void cm_message(const char *message) void cm_reset_overrides() { - cm.gmx.m48_enable = true; - cm.gmx.mfo_enable = false; // feed rate overrides - cm.gmx.mfo_factor = 1.0; - cm.gmx.mto_enable = false; // traverse overrides - cm.gmx.mto_factor = 1.0; + cm->gmx.m48_enable = true; + cm->gmx.mfo_enable = false; // feed rate overrides + cm->gmx.mfo_factor = 1.0; + cm->gmx.mto_enable = false; // traverse overrides + cm->gmx.mto_factor = 1.0; } /* @@ -1505,7 +1510,7 @@ stat_t cm_m48_enable(uint8_t enable) // M48, M49 { // handle changes to feed override given new state of m48/m49 - cm.gmx.m48_enable = enable; // update state + cm->gmx.m48_enable = enable; // update state return (STAT_OK); } @@ -1553,33 +1558,33 @@ stat_t cm_mfo_enable(uint8_t enable) // M50 { bool new_enable = true; bool new_override = false; - if (cm.gf.parameter) { // if parameter is present in Gcode block - if (fp_ZERO(cm.gn.parameter)) { + if (cm->gf.parameter) { // if parameter is present in Gcode block + if (fp_ZERO(cm->gn.parameter)) { new_enable = false; // P0 disables override } else { - if (cm.gn.parameter < FEED_OVERRIDE_MIN) { + if (cm->gn.parameter < FEED_OVERRIDE_MIN) { return (STAT_INPUT_LESS_THAN_MIN_VALUE); } - if (cm.gn.parameter > FEED_OVERRIDE_MAX) { + if (cm->gn.parameter > FEED_OVERRIDE_MAX) { return (STAT_INPUT_EXCEEDS_MAX_VALUE); } - cm.gmx.mfo_factor = cm.gn.parameter; // it validates - store it. + cm->gmx.mfo_factor = cm->gn.parameter; // it validates - store it. new_override = true; } } - if (cm.gmx.m48_enable) { // if master enable is ON - if (new_enable && (new_override || !cm.gmx.mfo_enable)) { // 3 cases to start a ramp - mp_start_feed_override(FEED_OVERRIDE_RAMP_TIME, cm.gmx.mfo_factor); - } else if (cm.gmx.mfo_enable && !new_enable) { // case to turn off the ramp + if (cm->gmx.m48_enable) { // if master enable is ON + if (new_enable && (new_override || !cm->gmx.mfo_enable)) { // 3 cases to start a ramp + mp_start_feed_override(FEED_OVERRIDE_RAMP_TIME, cm->gmx.mfo_factor); + } else if (cm->gmx.mfo_enable && !new_enable) { // case to turn off the ramp mp_end_feed_override(FEED_OVERRIDE_RAMP_TIME); } } - cm.gmx.mfo_enable = new_enable; // always update the enable state + cm->gmx.mfo_enable = new_enable; // always update the enable state return (STAT_OK); } -// if ((new_enable && new_override) || (new_enable && !cm.gmx.mfo_enable)) { -// if (!(cm.gmx.mfo_enable && new_override)) { +// if ((new_enable && new_override) || (new_enable && !cm->gmx.mfo_enable)) { +// if (!(cm->gmx.mfo_enable && new_override)) { /************************************************ @@ -1603,7 +1608,7 @@ stat_t cm_mfo_enable(uint8_t enable) // M50 * If a queue flush request is also present the queue flush should be done first * * Below the request level, feedholds work like this: - * - The hold is initiated by calling cm_start_hold(). cm.hold_state is set to + * - The hold is initiated by calling cm_start_hold(). cm->hold_state is set to * FEEDHOLD_SYNC, motion_state is set to MOTION_HOLD, and the spindle is turned off * (if it it on). The remainder of feedhold * processing occurs in plan_exec.c in the mp_exec_aline() function. @@ -1667,23 +1672,23 @@ stat_t cm_mfo_enable(uint8_t enable) // M50 */ void cm_request_feedhold(void) { // honor request if not already in a feedhold and you are moving - if ((cm.hold_state == FEEDHOLD_OFF) && (cm.motion_state != MOTION_STOP)) { - cm.hold_state = FEEDHOLD_REQUESTED; + if ((cm->hold_state == FEEDHOLD_OFF) && (cm->motion_state != MOTION_STOP)) { + cm->hold_state = FEEDHOLD_REQUESTED; } } void cm_request_end_hold(void) { - if (cm.hold_state != FEEDHOLD_OFF) { - cm.end_hold_requested = true; + if (cm->hold_state != FEEDHOLD_OFF) { + cm->end_hold_requested = true; } } void cm_request_queue_flush() { - if ((cm.hold_state != FEEDHOLD_OFF) && // don't honor request unless you are in a feedhold - (cm.queue_flush_state == FLUSH_OFF)) { // ...and only once - cm.queue_flush_state = FLUSH_REQUESTED; // request planner flush once motion has stopped + if ((cm->hold_state != FEEDHOLD_OFF) && // don't honor request unless you are in a feedhold + (cm->queue_flush_state == FLUSH_OFF)) { // ...and only once + cm->queue_flush_state = FLUSH_REQUESTED; // request planner flush once motion has stopped // NOTE: we used to flush the input buffers, but this is handled in xio *prior* to queue flush now } @@ -1694,14 +1699,14 @@ void cm_request_queue_flush() */ stat_t cm_feedhold_sequencing_callback() { - if (cm.hold_state == FEEDHOLD_REQUESTED) { + if (cm->hold_state == FEEDHOLD_REQUESTED) { cm_start_hold(); // feed won't run unless the machine is moving } - if (cm.queue_flush_state == FLUSH_REQUESTED) { + if (cm->queue_flush_state == FLUSH_REQUESTED) { cm_queue_flush(); // queue flush won't run until runtime is idle } - if (cm.end_hold_requested) { - if (cm.queue_flush_state == FLUSH_OFF) { // either no flush or wait until it's done flushing + if (cm->end_hold_requested) { + if (cm->queue_flush_state == FLUSH_OFF) { // either no flush or wait until it's done flushing cm_end_hold(); } } @@ -1716,7 +1721,7 @@ stat_t cm_feedhold_sequencing_callback() */ bool cm_has_hold() { - return (cm.hold_state != FEEDHOLD_OFF); + return (cm->hold_state != FEEDHOLD_OFF); } void cm_start_hold() @@ -1725,22 +1730,22 @@ void cm_start_hold() cm_spindle_optional_pause(spindle.pause_on_hold); // pause if this option is selected cm_coolant_optional_pause(coolant.pause_on_hold); // pause if this option is selected cm_set_motion_state(MOTION_HOLD); - cm.hold_state = FEEDHOLD_SYNC; // invokes hold from aline execution + cm->hold_state = FEEDHOLD_SYNC; // invokes hold from aline execution } } void cm_end_hold() { - if (cm.hold_state == FEEDHOLD_HOLD) { - cm.end_hold_requested = false; + if (cm->hold_state == FEEDHOLD_HOLD) { + cm->end_hold_requested = false; mp_exit_hold_state(); // State machine cases: - if (cm.machine_state == MACHINE_ALARM) { + if (cm->machine_state == MACHINE_ALARM) { cm_spindle_off_immediate(); cm_coolant_off_immediate(); - } else if (cm.motion_state == MOTION_STOP) { // && (! MACHINE_ALARM) + } else if (cm->motion_state == MOTION_STOP) { // && (! MACHINE_ALARM) cm_spindle_off_immediate(); cm_coolant_off_immediate(); cm_cycle_end(); @@ -1762,10 +1767,10 @@ void cm_queue_flush() for (uint8_t axis = AXIS_X; axis < AXES; axis++) { // set all positions cm_set_position(axis, mp_get_runtime_absolute_position(axis)); } - if(cm.hold_state == FEEDHOLD_HOLD) { // end feedhold if we're in one + if(cm->hold_state == FEEDHOLD_HOLD) { // end feedhold if we're in one cm_end_hold(); } - cm.queue_flush_state = FLUSH_OFF; + cm->queue_flush_state = FLUSH_OFF; qr_request_queue_report(0); // request a queue report, since we've changed the number of buffers available } } @@ -1826,25 +1831,25 @@ static void _exec_program_finalize(float *value, bool *flag) cm_set_motion_state(MOTION_STOP); // Allow update in the alarm state, to accommodate queue flush (RAS) - if ((cm.cycle_state == CYCLE_MACHINING || cm.cycle_state == CYCLE_OFF) && -// (cm.machine_state != MACHINE_ALARM) && // omitted by OMC (RAS) - (cm.machine_state != MACHINE_SHUTDOWN)) { - cm.machine_state = (cmMachineState)value[0]; // don't update macs/cycs if we're in the middle of a canned cycle, - cm.cycle_state = CYCLE_OFF; // or if we're in machine alarm/shutdown mode + if ((cm->cycle_state == CYCLE_MACHINING || cm->cycle_state == CYCLE_OFF) && +// (cm->machine_state != MACHINE_ALARM) && // omitted by OMC (RAS) + (cm->machine_state != MACHINE_SHUTDOWN)) { + cm->machine_state = (cmMachineState)value[0]; // don't update macs/cycs if we're in the middle of a canned cycle, + cm->cycle_state = CYCLE_OFF; // or if we're in machine alarm/shutdown mode } // reset the rest of the states - cm.cycle_state = CYCLE_OFF; - cm.hold_state = FEEDHOLD_OFF; + cm->cycle_state = CYCLE_OFF; + cm->hold_state = FEEDHOLD_OFF; mp_zero_segment_velocity(); // for reporting purposes // perform the following resets if it's a program END if (((uint8_t)value[0]) == MACHINE_PROGRAM_END) { cm_suspend_origin_offsets(); // G92.2 - as per NIST // cm_reset_origin_offsets(); // G92.1 - alternative to above - cm_set_coord_system(cm.default_coord_system); // reset to default coordinate system - cm_select_plane(cm.default_select_plane); // reset to default arc plane - cm_set_distance_mode(cm.default_distance_mode); + cm_set_coord_system(cm->default_coord_system); // reset to default coordinate system + cm_select_plane(cm->default_select_plane); // reset to default arc plane + cm_set_distance_mode(cm->default_distance_mode); cm_set_arc_distance_mode(INCREMENTAL_MODE); // always the default cm_spindle_off_immediate(); // M5 cm_coolant_off_immediate(); // M9 @@ -1858,16 +1863,16 @@ static void _exec_program_finalize(float *value, bool *flag) void cm_cycle_start() { - if (cm.cycle_state == CYCLE_OFF) { // don't (re)start homing, probe or other canned cycles - cm.machine_state = MACHINE_CYCLE; - cm.cycle_state = CYCLE_MACHINING; + if (cm->cycle_state == CYCLE_OFF) { // don't (re)start homing, probe or other canned cycles + cm->machine_state = MACHINE_CYCLE; + cm->cycle_state = CYCLE_MACHINING; qr_init_queue_report(); // clear queue reporting buffer counts } } void cm_cycle_end() { - if(cm.cycle_state == CYCLE_MACHINING) { + if(cm->cycle_state == CYCLE_MACHINING) { float value[] = { (float)MACHINE_PROGRAM_STOP, 0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; _exec_program_finalize(value, flags); @@ -1876,7 +1881,7 @@ void cm_cycle_end() void cm_canned_cycle_end() { - cm.cycle_state = CYCLE_OFF; + cm->cycle_state = CYCLE_OFF; float value[] = { (float)MACHINE_PROGRAM_STOP, 0,0,0,0,0 }; bool flags[] = { 1,0,0,0,0,0 }; _exec_program_finalize(value, flags); @@ -2252,6 +2257,9 @@ stat_t cm_get_am(nvObj_t *nv) return(_get_msg_helper(nv, msg_am, nv->value)); } +#pragma GCC push_options +#pragma GCC optimize ("O0") + stat_t cm_set_am(nvObj_t *nv) // axis mode { if (_get_axis_type(nv->index) == 0) { // linear @@ -2259,10 +2267,22 @@ stat_t cm_set_am(nvObj_t *nv) // axis mode } else { if (nv->value > AXIS_MODE_MAX_ROTARY) { return (STAT_INPUT_VALUE_RANGE_ERROR);} } + cmAxisMode *am = (cmAxisMode *)cfgArray[nv->index].target; + void *p = (cfgArray[nv->index].target); + cmAxisMode a = *((cmAxisMode *)cfgArray[nv->index].target); +// *((uint8_t *)cfgArray[nv->index].target) = nv->value; +// cmAxisMode a = (cmAxisMode)nv->value; +// *am = (cmAxisMode)nv->value; + *am = a; + nv->valuetype = TYPE_INT; + return(STAT_OK); + set_ui8(nv); return(STAT_OK); } +#pragma GCC reset_options + stat_t cm_set_hi(nvObj_t *nv) { if ((nv->value < 0) || (nv->value > D_IN_CHANNELS)) { @@ -2293,7 +2313,7 @@ stat_t cm_set_hi(nvObj_t *nv) */ float cm_get_axis_jerk(const uint8_t axis) { - return (cm.a[axis].jerk_max); + return (cm->a[axis].jerk_max); } // Precompute sqrt(3)/10 for the max_junction_accel. @@ -2303,16 +2323,16 @@ static const float _junction_accel_multiplier = sqrt(3.0)/10.0; // Important note: Actual jerk is stored jerk * JERK_MULTIPLIER, and // Time Quanta is junction_integration_time / 1000. void _cm_recalc_max_junction_accel(const uint8_t axis) { - float T = cm.junction_integration_time / 1000.0; + float T = cm->junction_integration_time / 1000.0; float T2 = T*T; - cm.a[axis].max_junction_accel = _junction_accel_multiplier * T2 * (cm.a[axis].jerk_max * JERK_MULTIPLIER); + cm->a[axis].max_junction_accel = _junction_accel_multiplier * T2 * (cm->a[axis].jerk_max * JERK_MULTIPLIER); } void cm_set_axis_jerk(const uint8_t axis, const float jerk) { - cm.a[axis].jerk_max = jerk; - //cm.a[axis].recip_jerk = 1/(jerk * JERK_MULTIPLIER); + cm->a[axis].jerk_max = jerk; + //cm->a[axis].recip_jerk = 1/(jerk * JERK_MULTIPLIER); // Must recalculate the max_junction_accel now that the jerk has changed. _cm_recalc_max_junction_accel(axis); @@ -2326,7 +2346,7 @@ stat_t cm_set_vm(nvObj_t *nv) } else { set_flu(nv); } - cm.a[axis].recip_velocity_max = 1/nv->value; + cm->a[axis].recip_velocity_max = 1/nv->value; return(STAT_OK); } @@ -2338,7 +2358,7 @@ stat_t cm_set_fr(nvObj_t *nv) } else { set_flu(nv); } - cm.a[axis].recip_feedrate_max = 1/nv->value; + cm->a[axis].recip_feedrate_max = 1/nv->value; return(STAT_OK); } @@ -2468,7 +2488,7 @@ stat_t cm_dam(nvObj_t *nv) float cm_get_jogging_dest(void) { - return cm.jogging_dest; + return cm->jogging_dest; } stat_t cm_run_jogx(nvObj_t *nv) diff --git a/g2core/canonical_machine.h b/g2core/canonical_machine.h index ee699091..c851a2c7 100644 --- a/g2core/canonical_machine.h +++ b/g2core/canonical_machine.h @@ -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 diff --git a/g2core/config_app.cpp b/g2core/config_app.cpp index ed913244..267dbfc6 100644 --- a/g2core/config_app.cpp +++ b/g2core/config_app.cpp @@ -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 diff --git a/g2core/controller.cpp b/g2core/controller.cpp index aa4df6e4..8955a3ca 100644 --- a/g2core/controller.cpp +++ b/g2core/controller.cpp @@ -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 diff --git a/g2core/cycle_homing.cpp b/g2core/cycle_homing.cpp old mode 100755 new mode 100644 index a66f3a20..1a37b393 --- a/g2core/cycle_homing.cpp +++ b/g2core/cycle_homing.cpp @@ -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); } } diff --git a/g2core/cycle_jogging.cpp b/g2core/cycle_jogging.cpp index 43d8ddd2..e161831e 100644 --- a/g2core/cycle_jogging.cpp +++ b/g2core/cycle_jogging.cpp @@ -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) { diff --git a/g2core/cycle_probing.cpp b/g2core/cycle_probing.cpp old mode 100755 new mode 100644 index c6ac4dba..52d18c41 --- a/g2core/cycle_probing.cpp +++ b/g2core/cycle_probing.cpp @@ -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); } diff --git a/g2core/gcode_parser.cpp b/g2core/gcode_parser.cpp index cd591cda..d302b4e7 100644 --- a/g2core/gcode_parser.cpp +++ b/g2core/gcode_parser.cpp @@ -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(); diff --git a/g2core/gpio.cpp b/g2core/gpio.cpp old mode 100755 new mode 100644 index 4ec98fb8..18992875 --- a/g2core/gpio.cpp +++ b/g2core/gpio.cpp @@ -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; } } diff --git a/g2core/json_parser.cpp b/g2core/json_parser.cpp old mode 100755 new mode 100644 index 9aa2abdd..e2c0b5e2 --- a/g2core/json_parser.cpp +++ b/g2core/json_parser.cpp @@ -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; diff --git a/g2core/kinematics.cpp b/g2core/kinematics.cpp old mode 100755 new mode 100644 index db55679a..9e200f61 --- a/g2core/kinematics.cpp +++ b/g2core/kinematics.cpp @@ -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; axisa[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; } diff --git a/g2core/main.cpp b/g2core/main.cpp old mode 100755 new mode 100644 index 8ec0c53e..048f39b0 --- a/g2core/main.cpp +++ b/g2core/main.cpp @@ -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 diff --git a/g2core/persistence.cpp b/g2core/persistence.cpp old mode 100755 new mode 100644 index b58d25ca..8644d6da --- a/g2core/persistence.cpp +++ b/g2core/persistence.cpp @@ -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); diff --git a/g2core/plan_arc.cpp b/g2core/plan_arc.cpp index d9dc6bc8..9c715e56 100644 --- a/g2core/plan_arc.cpp +++ b/g2core/plan_arc.cpp @@ -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) diff --git a/g2core/plan_exec.cpp b/g2core/plan_exec.cpp index 8727e4e4..04e49d90 100644 --- a/g2core/plan_exec.cpp +++ b/g2core/plan_exec.cpp @@ -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; diff --git a/g2core/plan_line.cpp b/g2core/plan_line.cpp index 1132345b..d76fd7a3 100644 --- a/g2core/plan_line.cpp +++ b/g2core/plan_line.cpp @@ -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; } } diff --git a/g2core/planner.cpp b/g2core/planner.cpp index eef111ac..e6f8c8e6 100644 --- a/g2core/planner.cpp +++ b/g2core/planner.cpp @@ -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 diff --git a/g2core/planner.h b/g2core/planner.h index 2192bbe5..dbac1cb1 100644 --- a/g2core/planner.h +++ b/g2core/planner.h @@ -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; diff --git a/g2core/spindle.cpp b/g2core/spindle.cpp old mode 100755 new mode 100644 index df86f333..00dd7c17 --- a/g2core/spindle.cpp +++ b/g2core/spindle.cpp @@ -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); } diff --git a/g2core/temperature.cpp b/g2core/temperature.cpp old mode 100755 new mode 100644 index a3666df7..f5209677 --- a/g2core/temperature.cpp +++ b/g2core/temperature.cpp @@ -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;