From d2a8b8642a2f9ebe798008858f3f5252c1082d16 Mon Sep 17 00:00:00 2001 From: Joseph Coffland Date: Wed, 6 Jul 2016 04:57:55 -0700 Subject: [PATCH] More cleanup --- src/axes.c | 48 ++-- src/command.c | 12 +- src/estop.c | 10 +- src/gcode_parser.c | 119 ++++----- src/homing.c | 114 ++++----- src/homing.h | 8 +- src/huanyang.c | 6 +- src/huanyang.h | 2 +- src/machine.c | 579 +++++++++++++++++++++++--------------------- src/machine.h | 292 +++++++++++----------- src/main.c | 8 +- src/motor.c | 10 +- src/motor.h | 8 +- src/plan/arc.c | 78 +++--- src/plan/arc.h | 6 +- src/plan/buffer.h | 4 +- src/plan/command.c | 15 +- src/plan/command.h | 2 +- src/plan/dwell.c | 4 +- src/plan/exec.c | 20 +- src/plan/feedhold.c | 20 +- src/plan/jog.c | 4 +- src/plan/line.c | 36 +-- src/plan/planner.c | 10 +- src/probing.c | 61 ++--- src/probing.h | 6 +- src/pwm_spindle.c | 4 +- src/pwm_spindle.h | 2 +- src/spindle.c | 20 +- src/spindle.h | 6 +- src/switch.c | 4 +- 31 files changed, 768 insertions(+), 750 deletions(-) diff --git a/src/axes.c b/src/axes.c index fb727ba..9bd3fb0 100644 --- a/src/axes.c +++ b/src/axes.c @@ -30,121 +30,121 @@ uint8_t get_axis_mode(int axis) { - return cm.a[axis].axis_mode; + return mach.a[axis].axis_mode; } void set_axis_mode(int axis, uint8_t value) { if (value < AXIS_MODE_MAX) - cm.a[axis].axis_mode = value; + mach.a[axis].axis_mode = value; } float get_max_velocity(int axis) { - return cm.a[axis].velocity_max; + return mach.a[axis].velocity_max; } void set_max_velocity(int axis, float value) { - cm.a[axis].velocity_max = value; + mach.a[axis].velocity_max = value; } float get_max_feedrate(int axis) { - return cm.a[axis].feedrate_max; + return mach.a[axis].feedrate_max; } void set_max_feedrate(int axis, float value) { - cm.a[axis].feedrate_max = value; + mach.a[axis].feedrate_max = value; } float get_max_jerk(int axis) { - return cm.a[axis].jerk_max; + return mach.a[axis].jerk_max; } void set_max_jerk(int axis, float value) { - cm.a[axis].jerk_max = value; + mach.a[axis].jerk_max = value; } float get_junction_dev(int axis) { - return cm.a[axis].junction_dev; + return mach.a[axis].junction_dev; } void set_junction_dev(int axis, float value) { - cm.a[axis].junction_dev = value; + mach.a[axis].junction_dev = value; } float get_travel_min(int axis) { - return cm.a[axis].travel_min; + return mach.a[axis].travel_min; } void set_travel_min(int axis, float value) { - cm.a[axis].travel_min = value; + mach.a[axis].travel_min = value; } float get_travel_max(int axis) { - return cm.a[axis].travel_max; + return mach.a[axis].travel_max; } void set_travel_max(int axis, float value) { - cm.a[axis].travel_max = value; + mach.a[axis].travel_max = value; } float get_jerk_homing(int axis) { - return cm.a[axis].jerk_homing; + return mach.a[axis].jerk_homing; } void set_jerk_homing(int axis, float value) { - cm.a[axis].jerk_homing = value; + mach.a[axis].jerk_homing = value; } float get_search_vel(int axis) { - return cm.a[axis].search_velocity; + return mach.a[axis].search_velocity; } void set_search_vel(int axis, float value) { - cm.a[axis].search_velocity = value; + mach.a[axis].search_velocity = value; } float get_latch_vel(int axis) { - return cm.a[axis].latch_velocity; + return mach.a[axis].latch_velocity; } void set_latch_vel(int axis, float value) { - cm.a[axis].latch_velocity = value; + mach.a[axis].latch_velocity = value; } float get_latch_backoff(int axis) { - return cm.a[axis].latch_backoff; + return mach.a[axis].latch_backoff; } void set_latch_backoff(int axis, float value) { - cm.a[axis].latch_backoff = value; + mach.a[axis].latch_backoff = value; } float get_zero_backoff(int axis) { - return cm.a[axis].zero_backoff; + return mach.a[axis].zero_backoff; } void set_zero_backoff(int axis, float value) { - cm.a[axis].zero_backoff = value; + mach.a[axis].zero_backoff = value; } diff --git a/src/command.c b/src/command.c index eff58c1..050d1c9 100644 --- a/src/command.c +++ b/src/command.c @@ -179,18 +179,18 @@ void command_callback() { default: if (!cmd[1]) switch (*cmd) { - case '!': cm_request_feedhold(); return; - case '~': cm_request_cycle_start(); return; - case '%': cm_request_queue_flush(); return; + case '!': mach_request_feedhold(); return; + case '~': mach_request_cycle_start(); return; + case '%': mach_request_queue_flush(); return; } if (estop_triggered()) status = STAT_MACHINE_ALARMED; else if (!mp_get_planner_buffer_room()) status = STAT_BUFFER_FULL; - else if (cm_arc_active()) status = STAT_BUFFER_FULL; + else if (mach_arc_active()) status = STAT_BUFFER_FULL; else if (calibrate_busy()) status = STAT_BUSY; else if (mp_jog_busy()) status = STAT_BUSY; - else if (cm_is_homing()) status = STAT_BUSY; - else if (cm_is_probing()) status = STAT_BUSY; + else if (mach_is_homing()) status = STAT_BUSY; + else if (mach_is_probing()) status = STAT_BUSY; else status = gc_gcode_parser(cmd); } diff --git a/src/estop.c b/src/estop.c index dc1a0e6..fbc9938 100644 --- a/src/estop.c +++ b/src/estop.c @@ -70,14 +70,14 @@ void estop_trigger() { // Hard stop the motors and the spindle st_shutdown(); - cm_spindle_control(SPINDLE_OFF); + mach_spindle_control(SPINDLE_OFF); // Stop and flush motion - cm_request_feedhold(); - cm_request_queue_flush(); + mach_request_feedhold(); + mach_request_queue_flush(); // Set alarm state - cm_set_machine_state(MACHINE_ALARM); + mach_set_machine_state(MACHINE_ALARM); // Assert fault signal OUTSET_PIN(FAULT_PIN); // High @@ -92,7 +92,7 @@ void estop_clear() { motor_reset(motor); // Clear alarm state - cm_set_machine_state(MACHINE_READY); + mach_set_machine_state(MACHINE_READY); // Clear fault signal OUTCLR_PIN(FAULT_PIN); // Low diff --git a/src/gcode_parser.c b/src/gcode_parser.c index d00e2dd..dca9e55 100644 --- a/src/gcode_parser.c +++ b/src/gcode_parser.c @@ -42,9 +42,9 @@ #define SET_MODAL(m, parm, val) \ - {cm.gn.parm = val; cm.gf.parm = 1; modals[m] += 1; break;} -#define SET_NON_MODAL(parm, val) {cm.gn.parm = val; cm.gf.parm = 1; break;} -#define EXEC_FUNC(f, v) if ((uint8_t)cm.gf.v) f(cm.gn.v) + {mach.gn.parm = val; mach.gf.parm = 1; modals[m] += 1; break;} +#define SET_NON_MODAL(parm, val) {mach.gn.parm = val; mach.gf.parm = 1; break;} +#define EXEC_FUNC(f, v) if ((uint8_t)mach.gf.v) f(mach.gn.v) static uint8_t modals[MODAL_GROUP_COUNT]; // collects modal groups in a block @@ -233,107 +233,108 @@ static stat_t _validate_gcode_block() { static stat_t _execute_gcode_block() { stat_t status = STAT_OK; - cm_set_model_line(cm.gn.line); - EXEC_FUNC(cm_set_feed_rate_mode, feed_rate_mode); - EXEC_FUNC(cm_set_feed_rate, feed_rate); - EXEC_FUNC(cm_feed_rate_override_factor, feed_rate_override_factor); - EXEC_FUNC(cm_traverse_override_factor, traverse_override_factor); - EXEC_FUNC(cm_set_spindle_speed, spindle_speed); - EXEC_FUNC(cm_spindle_override_factor, spindle_override_factor); - EXEC_FUNC(cm_select_tool, tool_select); - EXEC_FUNC(cm_change_tool, tool_change); - EXEC_FUNC(cm_spindle_control, spindle_mode); - EXEC_FUNC(cm_mist_coolant_control, mist_coolant); - EXEC_FUNC(cm_flood_coolant_control, flood_coolant); - EXEC_FUNC(cm_feed_rate_override_enable, feed_rate_override_enable); - EXEC_FUNC(cm_traverse_override_enable, traverse_override_enable); - EXEC_FUNC(cm_spindle_override_enable, spindle_override_enable); - EXEC_FUNC(cm_override_enables, override_enables); - - if (cm.gn.next_action == NEXT_ACTION_DWELL) // G4 - dwell - RITORNO(cm_dwell(cm.gn.parameter)); - - EXEC_FUNC(cm_set_plane, select_plane); - EXEC_FUNC(cm_set_units_mode, units_mode); + mach_set_model_line(mach.gn.line); + EXEC_FUNC(mach_set_feed_rate_mode, feed_rate_mode); + EXEC_FUNC(mach_set_feed_rate, feed_rate); + EXEC_FUNC(mach_feed_rate_override_factor, feed_rate_override_factor); + EXEC_FUNC(mach_traverse_override_factor, traverse_override_factor); + EXEC_FUNC(mach_set_spindle_speed, spindle_speed); + EXEC_FUNC(mach_spindle_override_factor, spindle_override_factor); + EXEC_FUNC(mach_select_tool, tool_select); + EXEC_FUNC(mach_change_tool, tool_change); + EXEC_FUNC(mach_spindle_control, spindle_mode); + EXEC_FUNC(mach_mist_coolant_control, mist_coolant); + EXEC_FUNC(mach_flood_coolant_control, flood_coolant); + EXEC_FUNC(mach_feed_rate_override_enable, feed_rate_override_enable); + EXEC_FUNC(mach_traverse_override_enable, traverse_override_enable); + EXEC_FUNC(mach_spindle_override_enable, spindle_override_enable); + EXEC_FUNC(mach_override_enables, override_enables); + + if (mach.gn.next_action == NEXT_ACTION_DWELL) // G4 - dwell + RITORNO(mach_dwell(mach.gn.parameter)); + + EXEC_FUNC(mach_set_plane, select_plane); + EXEC_FUNC(mach_set_units_mode, units_mode); //--> cutter radius compensation goes here //--> cutter length compensation goes here - EXEC_FUNC(cm_set_coord_system, coord_system); - EXEC_FUNC(cm_set_path_control, path_control); - EXEC_FUNC(cm_set_distance_mode, distance_mode); + EXEC_FUNC(mach_set_coord_system, coord_system); + EXEC_FUNC(mach_set_path_control, path_control); + EXEC_FUNC(mach_set_distance_mode, distance_mode); //--> set retract mode goes here - switch (cm.gn.next_action) { + switch (mach.gn.next_action) { case NEXT_ACTION_SET_G28_POSITION: // G28.1 - cm_set_g28_position(); + mach_set_g28_position(); break; case NEXT_ACTION_GOTO_G28_POSITION: // G28 - status = cm_goto_g28_position(cm.gn.target, cm.gf.target); + status = mach_goto_g28_position(mach.gn.target, mach.gf.target); break; case NEXT_ACTION_SET_G30_POSITION: // G30.1 - cm_set_g30_position(); + mach_set_g30_position(); break; case NEXT_ACTION_GOTO_G30_POSITION: // G30 - status = cm_goto_g30_position(cm.gn.target, cm.gf.target); + status = mach_goto_g30_position(mach.gn.target, mach.gf.target); break; case NEXT_ACTION_SEARCH_HOME: // G28.2 - cm_homing_cycle_start(); + mach_homing_cycle_start(); break; case NEXT_ACTION_SET_ABSOLUTE_ORIGIN: // G28.3 - cm_set_absolute_origin(cm.gn.target, cm.gf.target); + mach_set_absolute_origin(mach.gn.target, mach.gf.target); break; case NEXT_ACTION_HOMING_NO_SET: // G28.4 - cm_homing_cycle_start_no_set(); + mach_homing_cycle_start_no_set(); break; case NEXT_ACTION_STRAIGHT_PROBE: // G38.2 - status = cm_straight_probe(cm.gn.target, cm.gf.target); + status = mach_straight_probe(mach.gn.target, mach.gf.target); break; case NEXT_ACTION_SET_COORD_DATA: - cm_set_coord_offsets(cm.gn.parameter, cm.gn.target, cm.gf.target); + mach_set_coord_offsets(mach.gn.parameter, mach.gn.target, mach.gf.target); break; case NEXT_ACTION_SET_ORIGIN_OFFSETS: - cm_set_origin_offsets(cm.gn.target, cm.gf.target); + mach_set_origin_offsets(mach.gn.target, mach.gf.target); break; case NEXT_ACTION_RESET_ORIGIN_OFFSETS: - cm_reset_origin_offsets(); + mach_reset_origin_offsets(); break; case NEXT_ACTION_SUSPEND_ORIGIN_OFFSETS: - cm_suspend_origin_offsets(); + mach_suspend_origin_offsets(); break; case NEXT_ACTION_RESUME_ORIGIN_OFFSETS: - cm_resume_origin_offsets(); + mach_resume_origin_offsets(); break; case NEXT_ACTION_DWELL: break; // Handled above case NEXT_ACTION_DEFAULT: // apply override setting to gm struct - cm_set_absolute_override(cm.gn.absolute_override); + mach_set_absolute_override(mach.gn.absolute_override); - switch (cm.gn.motion_mode) { + switch (mach.gn.motion_mode) { case MOTION_MODE_CANCEL_MOTION_MODE: - cm.gm.motion_mode = cm.gn.motion_mode; + mach.gm.motion_mode = mach.gn.motion_mode; break; case MOTION_MODE_STRAIGHT_TRAVERSE: - status = cm_straight_traverse(cm.gn.target, cm.gf.target); + status = mach_straight_traverse(mach.gn.target, mach.gf.target); break; case MOTION_MODE_STRAIGHT_FEED: - status = cm_straight_feed(cm.gn.target, cm.gf.target); + status = mach_straight_feed(mach.gn.target, mach.gf.target); break; case MOTION_MODE_CW_ARC: case MOTION_MODE_CCW_ARC: // gf.radius sets radius mode if radius was collected in gn - status = cm_arc_feed(cm.gn.target, cm.gf.target, cm.gn.arc_offset[0], - cm.gn.arc_offset[1], cm.gn.arc_offset[2], - cm.gn.arc_radius, cm.gn.motion_mode); + status = mach_arc_feed(mach.gn.target, mach.gf.target, + mach.gn.arc_offset[0], mach.gn.arc_offset[1], + mach.gn.arc_offset[2], mach.gn.arc_radius, + mach.gn.motion_mode); break; default: break; // Should not get here } } // un-set absolute override once the move is planned - cm_set_absolute_override(false); + mach_set_absolute_override(false); // do the program stops and ends : M0, M1, M2, M30, M60 - if (cm.gf.program_flow) { - if (cm.gn.program_flow == PROGRAM_STOP) cm_program_stop(); - else cm_program_end(); + if (mach.gf.program_flow) { + if (mach.gn.program_flow == PROGRAM_STOP) mach_program_stop(); + else mach_program_end(); } return status; @@ -358,11 +359,11 @@ static stat_t _parse_gcode_block(char *buf) { // set initial state for new move memset(modals, 0, sizeof(modals)); // clear all parser values - memset(&cm.gf, 0, sizeof(GCodeState_t)); // clear all next-state flags - memset(&cm.gn, 0, sizeof(GCodeState_t)); // clear all next-state values + memset(&mach.gf, 0, sizeof(GCodeState_t)); // clear all next-state flags + memset(&mach.gn, 0, sizeof(GCodeState_t)); // clear all next-state values // get motion mode from previous block - cm.gn.motion_mode = cm_get_motion_mode(); + mach.gn.motion_mode = mach_get_motion_mode(); // extract commands and parameters while ((status = _get_next_gcode_word(&pstr, &letter, &value)) == STAT_OK) { @@ -535,7 +536,7 @@ stat_t gc_gcode_parser(char *block) { uint8_t block_delete_flag; // don't process Gcode blocks if in alarmed state - if (cm.machine_state == MACHINE_ALARM) return STAT_MACHINE_ALARMED; + if (mach.machine_state == MACHINE_ALARM) return STAT_MACHINE_ALARMED; _normalize_gcode_block(str, &com, &msg, &block_delete_flag); @@ -544,7 +545,7 @@ stat_t gc_gcode_parser(char *block) { if (block_delete_flag) return STAT_NOOP; // queue a "(MSG" response - if (*msg) cm_message(msg); // queue the message + if (*msg) mach_message(msg); // queue the message return _parse_gcode_block(block); } diff --git a/src/homing.c b/src/homing.c index a9efd44..7c700cf 100644 --- a/src/homing.c +++ b/src/homing.c @@ -135,7 +135,7 @@ static struct hmHomingSingleton hm; * the cycle to be done. Otherwise there is a nasty race condition * that will accept the next command before the position of * the final move has been recorded in the Gcode model. That's what the call - * to cm_isbusy() is about. + * to mach_isbusy() is about. */ @@ -153,12 +153,12 @@ static struct hmHomingSingleton hm; */ static int8_t _get_next_axis(int8_t axis) { switch (axis) { - case -1: if (fp_TRUE(cm.gf.target[AXIS_Z])) return AXIS_Z; - case AXIS_Z: if (fp_TRUE(cm.gf.target[AXIS_X])) return AXIS_X; - case AXIS_X: if (fp_TRUE(cm.gf.target[AXIS_Y])) return AXIS_Y; - case AXIS_Y: if (fp_TRUE(cm.gf.target[AXIS_A])) return AXIS_A; - case AXIS_A: if (fp_TRUE(cm.gf.target[AXIS_B])) return AXIS_B; - case AXIS_B: if (fp_TRUE(cm.gf.target[AXIS_C])) return AXIS_C; + case -1: if (fp_TRUE(mach.gf.target[AXIS_Z])) return AXIS_Z; + case AXIS_Z: if (fp_TRUE(mach.gf.target[AXIS_X])) return AXIS_X; + case AXIS_X: if (fp_TRUE(mach.gf.target[AXIS_Y])) return AXIS_Y; + case AXIS_Y: if (fp_TRUE(mach.gf.target[AXIS_A])) return AXIS_A; + case AXIS_A: if (fp_TRUE(mach.gf.target[AXIS_B])) return AXIS_B; + case AXIS_B: if (fp_TRUE(mach.gf.target[AXIS_C])) return AXIS_C; } return axis == -1 ? -2 : -1; // error or done @@ -170,14 +170,14 @@ static void _homing_finalize_exit() { mp_flush_planner(); // should be stopped, but in case of switch closure // restore to work coordinate system - cm_set_coord_system(hm.saved_coord_system); - cm_set_units_mode(hm.saved_units_mode); - cm_set_distance_mode(hm.saved_distance_mode); - cm_set_feed_rate_mode(hm.saved_feed_rate_mode); - cm.gm.feed_rate = hm.saved_feed_rate; - cm_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); - cm_cycle_end(); - cm.cycle_state = CYCLE_OFF; + mach_set_coord_system(hm.saved_coord_system); + mach_set_units_mode(hm.saved_units_mode); + mach_set_distance_mode(hm.saved_distance_mode); + mach_set_feed_rate_mode(hm.saved_feed_rate_mode); + mach.gm.feed_rate = hm.saved_feed_rate; + mach_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); + mach_cycle_end(); + mach.cycle_state = CYCLE_OFF; } @@ -194,18 +194,18 @@ static void _homing_axis_move(int8_t axis, float target, float velocity) { vect[axis] = target; flags[axis] = true; - cm.gm.feed_rate = velocity; - mp_flush_planner(); // don't use cm_request_queue_flush() here - cm_request_cycle_start(); + mach.gm.feed_rate = velocity; + mp_flush_planner(); // don't use mach_request_queue_flush() here + mach_request_cycle_start(); - stat_t status = cm_straight_feed(vect, flags); + stat_t status = mach_straight_feed(vect, flags); if (status) _homing_error_exit(status); } /// End homing cycle in progress static void _homing_abort(int8_t axis) { - cm_set_axis_jerk(axis, hm.saved_jerk); // restore the max jerk value + mach_set_axis_jerk(axis, hm.saved_jerk); // restore the max jerk value // homing state remains HOMING_NOT_HOMED _homing_error_exit(STAT_HOMING_CYCLE_FAILED); @@ -217,13 +217,13 @@ static void _homing_abort(int8_t axis) { /// set zero and finish up static void _homing_axis_set_zero(int8_t axis) { if (hm.set_coordinates) { - cm_set_position(axis, 0); - cm.homed[axis] = true; + mach_set_position(axis, 0); + mach.homed[axis] = true; } else // do not set axis if in G28.4 cycle - cm_set_position(axis, mp_get_runtime_work_position(axis)); + mach_set_position(axis, mp_get_runtime_work_position(axis)); - cm_set_axis_jerk(axis, hm.saved_jerk); // restore the max jerk value + mach_set_axis_jerk(axis, hm.saved_jerk); // restore the max jerk value hm.func = _homing_axis_start; } @@ -252,7 +252,7 @@ static void _homing_axis_latch(int8_t axis) { /// Fast search for switch, closes switch static void _homing_axis_search(int8_t axis) { // use the homing jerk for search onward - cm_set_axis_jerk(axis, cm.a[axis].jerk_homing); + mach_set_axis_jerk(axis, mach.a[axis].jerk_homing); _homing_axis_move(axis, hm.search_travel, hm.search_velocity); hm.func = _homing_axis_latch; } @@ -278,7 +278,7 @@ static void _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; + mach.homing_state = HOMING_HOMED; _homing_finalize_exit(); return; @@ -287,28 +287,28 @@ static void _homing_axis_start(int8_t axis) { } // clear the homed flag for axis to move w/o triggering soft limits - cm.homed[axis] = false; + mach.homed[axis] = false; // trap axis mis-configurations - if (fp_ZERO(cm.a[axis].search_velocity)) + if (fp_ZERO(mach.a[axis].search_velocity)) return _homing_error_exit(STAT_HOMING_ERROR_ZERO_SEARCH_VELOCITY); - if (fp_ZERO(cm.a[axis].latch_velocity)) + if (fp_ZERO(mach.a[axis].latch_velocity)) return _homing_error_exit(STAT_HOMING_ERROR_ZERO_LATCH_VELOCITY); - if (cm.a[axis].latch_backoff < 0) + if (mach.a[axis].latch_backoff < 0) return _homing_error_exit(STAT_HOMING_ERROR_NEGATIVE_LATCH_BACKOFF); // calculate and test travel distance float travel_distance = - fabs(cm.a[axis].travel_max - cm.a[axis].travel_min) + - cm.a[axis].latch_backoff; + fabs(mach.a[axis].travel_max - mach.a[axis].travel_min) + + mach.a[axis].latch_backoff; if (fp_ZERO(travel_distance)) return _homing_error_exit(STAT_HOMING_ERROR_TRAVEL_MIN_MAX_IDENTICAL); hm.axis = axis; // persist the axis // search velocity is always positive - hm.search_velocity = fabs(cm.a[axis].search_velocity); + hm.search_velocity = fabs(mach.a[axis].search_velocity); // latch velocity is always positive - hm.latch_velocity = fabs(cm.a[axis].latch_velocity); + hm.latch_velocity = fabs(mach.a[axis].latch_velocity); // determine which switch to use bool min_enabled = switch_is_enabled(MIN_SWITCH(axis)); @@ -319,16 +319,16 @@ static void _homing_axis_start(int8_t axis) { hm.homing_switch = MIN_SWITCH(axis); // min is the homing switch hm.limit_switch = MAX_SWITCH(axis); // max would be limit switch hm.search_travel = -travel_distance; // in negative direction - hm.latch_backoff = cm.a[axis].latch_backoff; // in positive direction - hm.zero_backoff = cm.a[axis].zero_backoff; + hm.latch_backoff = mach.a[axis].latch_backoff; // in positive direction + hm.zero_backoff = mach.a[axis].zero_backoff; } else if (max_enabled) { // setup parameters for positive travel (homing to the maximum switch) hm.homing_switch = MAX_SWITCH(axis); // max is homing switch hm.limit_switch = MIN_SWITCH(axis); // min would be limit switch hm.search_travel = travel_distance; // in positive direction - hm.latch_backoff = -cm.a[axis].latch_backoff; // in negative direction - hm.zero_backoff = -cm.a[axis].zero_backoff; + hm.latch_backoff = -mach.a[axis].latch_backoff; // in negative direction + hm.zero_backoff = -mach.a[axis].zero_backoff; } else { // if homing is disabled for the axis then skip to the next axis @@ -337,47 +337,47 @@ static void _homing_axis_start(int8_t axis) { return; } - hm.saved_jerk = cm_get_axis_jerk(axis); // save the max jerk value + hm.saved_jerk = mach_get_axis_jerk(axis); // save the max jerk value hm.func = _homing_axis_clear; // start the clear } -bool cm_is_homing() { - return cm.cycle_state == CYCLE_HOMING; +bool mach_is_homing() { + return mach.cycle_state == CYCLE_HOMING; } /// G28.2 homing cycle using limit switches -void cm_homing_cycle_start() { +void mach_homing_cycle_start() { // save relevant non-axis parameters from Gcode model - hm.saved_units_mode = cm_get_units_mode(&cm.gm); - hm.saved_coord_system = cm_get_coord_system(&cm.gm); - hm.saved_distance_mode = cm_get_distance_mode(&cm.gm); - hm.saved_feed_rate_mode = cm_get_feed_rate_mode(&cm.gm); - hm.saved_feed_rate = cm_get_feed_rate(&cm.gm); + hm.saved_units_mode = mach_get_units_mode(&mach.gm); + hm.saved_coord_system = mach_get_coord_system(&mach.gm); + hm.saved_distance_mode = mach_get_distance_mode(&mach.gm); + hm.saved_feed_rate_mode = mach_get_feed_rate_mode(&mach.gm); + hm.saved_feed_rate = mach_get_feed_rate(&mach.gm); // set working values - cm_set_units_mode(MILLIMETERS); - cm_set_distance_mode(INCREMENTAL_MODE); - cm_set_coord_system(ABSOLUTE_COORDS); // in machine coordinates - cm_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); + mach_set_units_mode(MILLIMETERS); + mach_set_distance_mode(INCREMENTAL_MODE); + mach_set_coord_system(ABSOLUTE_COORDS); // in machine coordinates + mach_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); hm.set_coordinates = true; hm.axis = -1; // set to retrieve initial axis hm.func = _homing_axis_start; // bind initial processing function - cm.cycle_state = CYCLE_HOMING; - cm.homing_state = HOMING_NOT_HOMED; + mach.cycle_state = CYCLE_HOMING; + mach.homing_state = HOMING_NOT_HOMED; } -void cm_homing_cycle_start_no_set() { - cm_homing_cycle_start(); +void mach_homing_cycle_start_no_set() { + mach_homing_cycle_start(); hm.set_coordinates = false; // don't update position variables at end of cycle } /// Main loop callback for running the homing cycle -void cm_homing_callback() { - if (cm.cycle_state != CYCLE_HOMING || cm_get_runtime_busy()) return; +void mach_homing_callback() { + if (mach.cycle_state != CYCLE_HOMING || mach_get_runtime_busy()) return; hm.func(hm.axis); // execute the current homing move } diff --git a/src/homing.h b/src/homing.h index 738f914..16a2c20 100644 --- a/src/homing.h +++ b/src/homing.h @@ -30,7 +30,7 @@ #include -bool cm_is_homing(); -void cm_homing_cycle_start(); -void cm_homing_cycle_start_no_set(); -void cm_homing_callback(); +bool mach_is_homing(); +void mach_homing_cycle_start(); +void mach_homing_cycle_start_no_set(); +void mach_homing_callback(); diff --git a/src/huanyang.c b/src/huanyang.c index 9c67189..4167e2f 100644 --- a/src/huanyang.c +++ b/src/huanyang.c @@ -113,7 +113,7 @@ typedef struct { bool connected; bool changed; - cmSpindleMode_t mode; + machSpindleMode_t mode; float speed; float actual_freq; @@ -449,7 +449,7 @@ void huanyang_init() { } -void huanyang_set(cmSpindleMode_t mode, float speed) { +void huanyang_set(machSpindleMode_t mode, float speed) { if (ha.mode != mode || ha.speed != speed) { if (ha.debug) STATUS_DEBUG("huanyang: mode=%d, speed=%0.2f", mode, speed); @@ -473,7 +473,7 @@ void huanyang_reset() { // Save settings uint8_t id = ha.id; - cmSpindleMode_t mode = ha.mode; + machSpindleMode_t mode = ha.mode; float speed = ha.speed; bool debug = ha.debug; diff --git a/src/huanyang.h b/src/huanyang.h index fce7aa0..d3a6e9a 100644 --- a/src/huanyang.h +++ b/src/huanyang.h @@ -31,6 +31,6 @@ void huanyang_init(); -void huanyang_set(cmSpindleMode_t mode, float speed); +void huanyang_set(machSpindleMode_t mode, float speed); void huanyang_reset(); void huanyang_rtc_callback(); diff --git a/src/machine.c b/src/machine.c index cdbe35b..3710c5d 100644 --- a/src/machine.c +++ b/src/machine.c @@ -43,10 +43,10 @@ * into the planner queue and execute from the queue. Synchronous * commands work like this: * - * - Call the cm_xxx_xxx() function which will do any input + * - Call the mach_xxx_xxx() function which will do any input * validation and return an error if it detects one. * - * - The cm_ function calls mp_queue_command(). Arguments are a + * - The mach_ function calls mp_queue_command(). Arguments are a * callback to the _exec_...() function, which is the runtime * execution routine, and any arguments that are needed by the * runtime. See typedef for *exec in planner.h for details @@ -92,7 +92,7 @@ #include -cmSingleton_t cm = { +machSingleton_t mach = { // Offsets .offset = { {}, // ABSOLUTE_COORDS @@ -203,72 +203,78 @@ static void _exec_program_finalize(float *value, float *flag); // Machine State functions /// Combines raw states into something a user might want to see -cmCombinedState_t cm_get_combined_state() { - if (cm.cycle_state == CYCLE_OFF) cm.combined_state = cm.machine_state; - else if (cm.cycle_state == CYCLE_PROBE) cm.combined_state = COMBINED_PROBE; - else if (cm.cycle_state == CYCLE_HOMING) cm.combined_state = COMBINED_HOMING; +machCombinedState_t mach_get_combined_state() { + if (mach.cycle_state == CYCLE_OFF) mach.combined_state = mach.machine_state; + else if (mach.cycle_state == CYCLE_PROBE) + mach.combined_state = COMBINED_PROBE; + else if (mach.cycle_state == CYCLE_HOMING) + mach.combined_state = COMBINED_HOMING; else { - if (cm.motion_state == MOTION_RUN) cm.combined_state = COMBINED_RUN; - if (cm.motion_state == MOTION_HOLD) cm.combined_state = COMBINED_HOLD; + if (mach.motion_state == MOTION_RUN) mach.combined_state = COMBINED_RUN; + if (mach.motion_state == MOTION_HOLD) mach.combined_state = COMBINED_HOLD; } - if (cm.machine_state == MACHINE_SHUTDOWN) - cm.combined_state = COMBINED_SHUTDOWN; + if (mach.machine_state == MACHINE_SHUTDOWN) + mach.combined_state = COMBINED_SHUTDOWN; - return cm.combined_state; + return mach.combined_state; } -uint32_t cm_get_line() {return cm.gm.line;} -cmMachineState_t cm_get_machine_state() {return cm.machine_state;} -cmCycleState_t cm_get_cycle_state() {return cm.cycle_state;} -cmMotionState_t cm_get_motion_state() {return cm.motion_state;} -cmFeedholdState_t cm_get_hold_state() {return cm.hold_state;} -cmHomingState_t cm_get_homing_state() {return cm.homing_state;} -cmMotionMode_t cm_get_motion_mode() {return cm.gm.motion_mode;} -cmCoordSystem_t cm_get_coord_system() {return cm.gm.coord_system;} -cmUnitsMode_t cm_get_units_mode() {return cm.gm.units_mode;} -cmPlane_t cm_get_select_plane() {return cm.gm.select_plane;} -cmPathControlMode_t cm_get_path_control() {return cm.gm.path_control;} -cmDistanceMode_t cm_get_distance_mode() {return cm.gm.distance_mode;} -cmFeedRateMode_t cm_get_feed_rate_mode() {return cm.gm.feed_rate_mode;} -uint8_t cm_get_tool() {return cm.gm.tool;} -cmSpindleMode_t cm_get_spindle_mode() {return cm.gm.spindle_mode;} -bool cm_get_runtime_busy() {return mp_get_runtime_busy();} -float cm_get_feed_rate() {return cm.gm.feed_rate;} +uint32_t mach_get_line() {return mach.gm.line;} +machMachineState_t mach_get_machine_state() {return mach.machine_state;} +machCycleState_t mach_get_cycle_state() {return mach.cycle_state;} +machMotionState_t mach_get_motion_state() {return mach.motion_state;} +machFeedholdState_t mach_get_hold_state() {return mach.hold_state;} +machHomingState_t mach_get_homing_state() {return mach.homing_state;} +machMotionMode_t mach_get_motion_mode() {return mach.gm.motion_mode;} +machCoordSystem_t mach_get_coord_system() {return mach.gm.coord_system;} +machUnitsMode_t mach_get_units_mode() {return mach.gm.units_mode;} +machPlane_t mach_get_select_plane() {return mach.gm.select_plane;} +machPathControlMode_t mach_get_path_control() {return mach.gm.path_control;} +machDistanceMode_t mach_get_distance_mode() {return mach.gm.distance_mode;} +machFeedRateMode_t mach_get_feed_rate_mode() {return mach.gm.feed_rate_mode;} +uint8_t mach_get_tool() {return mach.gm.tool;} +machSpindleMode_t mach_get_spindle_mode() {return mach.gm.spindle_mode;} +bool mach_get_runtime_busy() {return mp_get_runtime_busy();} +float mach_get_feed_rate() {return mach.gm.feed_rate;} + + +void mach_set_machine_state(machMachineState_t machine_state) { + mach.machine_state = machine_state; +} -void cm_set_machine_state(cmMachineState_t machine_state) { - cm.machine_state = machine_state; +void mach_set_motion_state(machMotionState_t motion_state) { + mach.motion_state = motion_state; } -void cm_set_motion_state(cmMotionState_t motion_state) { - cm.motion_state = motion_state; +void mach_set_motion_mode(machMotionMode_t motion_mode) { + mach.gm.motion_mode = motion_mode; } -void cm_set_motion_mode(cmMotionMode_t motion_mode) { - cm.gm.motion_mode = motion_mode; +void mach_set_spindle_mode(machSpindleMode_t spindle_mode) { + mach.gm.spindle_mode = spindle_mode; } -void cm_set_spindle_mode(cmSpindleMode_t spindle_mode) { - cm.gm.spindle_mode = spindle_mode; +void mach_set_spindle_speed_parameter(float speed) { + mach.gm.spindle_speed = speed; } -void cm_set_spindle_speed_parameter(float speed) {cm.gm.spindle_speed = speed;} -void cm_set_tool_number(uint8_t tool) {cm.gm.tool = tool;} +void mach_set_tool_number(uint8_t tool) {mach.gm.tool = tool;} -void cm_set_absolute_override(bool absolute_override) { - cm.gm.absolute_override = absolute_override; +void mach_set_absolute_override(bool absolute_override) { + mach.gm.absolute_override = absolute_override; // must reset offsets if you change absolute override - cm_set_work_offsets(); + mach_set_work_offsets(); } -void cm_set_model_line(uint32_t line) {cm.gm.line = line;} +void mach_set_model_line(uint32_t line) {mach.gm.line = line;} /* Jerk functions @@ -282,15 +288,15 @@ void cm_set_model_line(uint32_t line) {cm.gm.line = line;} */ /// returns jerk for an axis -float cm_get_axis_jerk(uint8_t axis) { - return cm.a[axis].jerk_max; +float mach_get_axis_jerk(uint8_t axis) { + return mach.a[axis].jerk_max; } /// sets the jerk for an axis, including recirpcal and cached values -void cm_set_axis_jerk(uint8_t axis, float jerk) { - cm.a[axis].jerk_max = jerk; - cm.a[axis].recip_jerk = 1 / (jerk * JERK_MULTIPLIER); +void mach_set_axis_jerk(uint8_t axis, float jerk) { + mach.a[axis].jerk_max = jerk; + mach.a[axis].recip_jerk = 1 / (jerk * JERK_MULTIPLIER); } @@ -316,7 +322,7 @@ void cm_set_axis_jerk(uint8_t axis, float jerk) { * if origin_offset_enable * - G28 and G30 moves; these are run in absolute coordinates * - * The offsets themselves are considered static, are kept in cm, and are + * The offsets themselves are considered static, are kept in mach, and are * supposed to be persistent. * * To reduce complexity and data load the following is done: @@ -334,30 +340,31 @@ void cm_set_axis_jerk(uint8_t axis, float jerk) { * active offset for this move * * This function is typically used to evaluate and set offsets, as - * opposed to cm_get_work_offset() which merely returns what's in the + * opposed to mach_get_work_offset() which merely returns what's in the * work_offset[] array. */ -float cm_get_active_coord_offset(uint8_t axis) { - if (cm.gm.absolute_override) return 0; // no offset in absolute override mode - float offset = cm.offset[cm.gm.coord_system][axis]; +float mach_get_active_coord_offset(uint8_t axis) { + // no offset in absolute override mode + if (mach.gm.absolute_override) return 0; + float offset = mach.offset[mach.gm.coord_system][axis]; - if (cm.origin_offset_enable) - offset += cm.origin_offset[axis]; // includes G5x and G92 components + if (mach.origin_offset_enable) + offset += mach.origin_offset[axis]; // includes G5x and G92 components return offset; } /// Return a coord offset -float cm_get_work_offset(uint8_t axis) { - return cm.ms.work_offset[axis]; +float mach_get_work_offset(uint8_t axis) { + return mach.ms.work_offset[axis]; } // Capture coord offsets from the model into absolute values -void cm_set_work_offsets() { +void mach_set_work_offsets() { for (int axis = 0; axis < AXES; axis++) - cm.ms.work_offset[axis] = cm_get_active_coord_offset(axis); + mach.ms.work_offset[axis] = mach_get_active_coord_offset(axis); } @@ -366,8 +373,8 @@ void cm_set_work_offsets() { * NOTE: Machine position is always returned in mm mode. No units conversion * is performed */ -float cm_get_absolute_position(uint8_t axis) { - return cm.position[axis]; +float mach_get_absolute_position(uint8_t axis) { + return mach.position[axis]; } @@ -375,12 +382,12 @@ float cm_get_absolute_position(uint8_t axis) { * applied. * * NOTE: This function only works after the gcode_state struct has had the - * work_offsets setup by calling cm_get_model_coord_offset_vector() first. + * work_offsets setup by calling mach_get_model_coord_offset_vector() first. */ -float cm_get_work_position(uint8_t axis) { - float position = cm.position[axis] - cm_get_active_coord_offset(axis); +float mach_get_work_position(uint8_t axis) { + float position = mach.position[axis] - mach_get_active_coord_offset(axis); - if (cm.gm.units_mode == INCHES) position /= MM_PER_INCH; + if (mach.gm.units_mode == INCHES) position /= MM_PER_INCH; return position; } @@ -403,14 +410,14 @@ float cm_get_work_position(uint8_t axis) { * the move for later execution, and the real tool position is still * close to the starting point. */ -void cm_finalize_move() { - copy_vector(cm.position, cm.ms.target); // update model position +void mach_finalize_move() { + copy_vector(mach.position, mach.ms.target); // update model position // if in ivnerse time mode reset feed rate so next block requires an // explicit feed rate setting - if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE && - cm.gm.motion_mode == MOTION_MODE_STRAIGHT_FEED) - cm.gm.feed_rate = 0; + if (mach.gm.feed_rate_mode == INVERSE_TIME_MODE && + mach.gm.motion_mode == MOTION_MODE_STRAIGHT_FEED) + mach.gm.feed_rate = 0; } @@ -429,7 +436,7 @@ void cm_finalize_move() { * time. * * The gcode state must have targets set prior by having - * cm_set_target(). Axis modes are taken into account by this. + * mach_set_target(). Axis modes are taken into account by this. * * The following times are compared and the longest is returned: * - G93 inverse time (if G93 is active) @@ -480,7 +487,7 @@ void cm_finalize_move() { * from the start to the end of the motion is T plus any time * required for acceleration or deceleration. */ -void cm_calc_move_time(const float axis_length[], const float axis_square[]) { +void mach_calc_move_time(const float axis_length[], const float axis_square[]) { float inv_time = 0; // inverse time if doing a feed in G93 mode float xyz_time = 0; // linear coordinated move at requested feed float abc_time = 0; // rotary coordinated move at requested feed @@ -488,43 +495,43 @@ void cm_calc_move_time(const float axis_length[], const float axis_square[]) { float tmp_time = 0; // used in computation // compute times for feed motion - if (cm.gm.motion_mode != MOTION_MODE_STRAIGHT_TRAVERSE) { - if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE) { - // feed rate was un-inverted to minutes by cm_set_feed_rate() - inv_time = cm.gm.feed_rate; - cm.gm.feed_rate_mode = UNITS_PER_MINUTE_MODE; + if (mach.gm.motion_mode != MOTION_MODE_STRAIGHT_TRAVERSE) { + if (mach.gm.feed_rate_mode == INVERSE_TIME_MODE) { + // feed rate was un-inverted to minutes by mach_set_feed_rate() + inv_time = mach.gm.feed_rate; + mach.gm.feed_rate_mode = UNITS_PER_MINUTE_MODE; } else { // compute length of linear move in millimeters. Feed rate is provided as // mm/min xyz_time = sqrt(axis_square[AXIS_X] + axis_square[AXIS_Y] + - axis_square[AXIS_Z]) / cm.gm.feed_rate; + axis_square[AXIS_Z]) / mach.gm.feed_rate; // if no linear axes, compute length of multi-axis rotary move in degrees. // Feed rate is provided as degrees/min if (fp_ZERO(xyz_time)) abc_time = sqrt(axis_square[AXIS_A] + axis_square[AXIS_B] + - axis_square[AXIS_C]) / cm.gm.feed_rate; + axis_square[AXIS_C]) / mach.gm.feed_rate; } } for (uint8_t axis = 0; axis < AXES; axis++) { - if (cm.gm.motion_mode == MOTION_MODE_STRAIGHT_TRAVERSE) - tmp_time = fabs(axis_length[axis]) / cm.a[axis].velocity_max; + if (mach.gm.motion_mode == MOTION_MODE_STRAIGHT_TRAVERSE) + tmp_time = fabs(axis_length[axis]) / mach.a[axis].velocity_max; else // MOTION_MODE_STRAIGHT_FEED - tmp_time = fabs(axis_length[axis]) / cm.a[axis].feedrate_max; + tmp_time = fabs(axis_length[axis]) / mach.a[axis].feedrate_max; max_time = max(max_time, tmp_time); } - cm.ms.move_time = max4(inv_time, max_time, xyz_time, abc_time); + mach.ms.move_time = max4(inv_time, max_time, xyz_time, abc_time); } /// Set endpoint position from final runtime position -void cm_update_model_position_from_runtime() { - copy_vector(cm.position, mr.ms.target); +void mach_update_model_position_from_runtime() { + copy_vector(mach.position, mr.ms.target); } @@ -554,41 +561,41 @@ void cm_update_model_position_from_runtime() { // get a fresh stack push // ALDEN: This shows up in avr-gcc 4.7.0 and avr-libc 1.8.0 static float _calc_ABC(uint8_t axis, float target[], float flag[]) { - if (cm.a[axis].axis_mode == AXIS_STANDARD || - cm.a[axis].axis_mode == AXIS_INHIBITED) + if (mach.a[axis].axis_mode == AXIS_STANDARD || + mach.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 * mach.a[axis].radius); } -void cm_set_model_target(float target[], float flag[]) { +void mach_set_model_target(float target[], float flag[]) { float tmp = 0; // process XYZABC for lower modes for (int axis = AXIS_X; axis <= AXIS_Z; axis++) { - if (fp_FALSE(flag[axis]) || cm.a[axis].axis_mode == AXIS_DISABLED) + if (fp_FALSE(flag[axis]) || mach.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.ms.target[axis] = - cm_get_active_coord_offset(axis) + TO_MILLIMETERS(target[axis]); - else cm.ms.target[axis] += TO_MILLIMETERS(target[axis]); + else if (mach.a[axis].axis_mode == AXIS_STANDARD || + mach.a[axis].axis_mode == AXIS_INHIBITED) { + if (mach.gm.distance_mode == ABSOLUTE_MODE) + mach.ms.target[axis] = + mach_get_active_coord_offset(axis) + TO_MILLIMETERS(target[axis]); + else mach.ms.target[axis] += TO_MILLIMETERS(target[axis]); } } // FYI: The ABC loop below relies on the XYZ loop having been run first for (int axis = AXIS_A; axis <= AXIS_C; axis++) { - if (fp_FALSE(flag[axis]) || cm.a[axis].axis_mode == AXIS_DISABLED) + if (fp_FALSE(flag[axis]) || mach.a[axis].axis_mode == AXIS_DISABLED) continue; // skip axis if not flagged for update or its disabled else tmp = _calc_ABC(axis, target, flag); - if (cm.gm.distance_mode == ABSOLUTE_MODE) + if (mach.gm.distance_mode == ABSOLUTE_MODE) // sacidu93's fix to Issue #22 - cm.ms.target[axis] = tmp + cm_get_active_coord_offset(axis); - else cm.ms.target[axis] += tmp; + mach.ms.target[axis] = tmp + mach_get_active_coord_offset(axis); + else mach.ms.target[axis] += tmp; } } @@ -596,7 +603,7 @@ void cm_set_model_target(float target[], float flag[]) { /* Return error code if soft limit is exceeded * * Must be called with target properly set in GM struct. Best done - * after cm_set_model_target(). + * after mach_set_model_target(). * * Tests for soft limit for any homed axis if min and max are * different values. You can set min and max to 0,0 to disable soft @@ -604,19 +611,19 @@ void cm_set_model_target(float target[], float flag[]) { * is < -1000000 (negative one million). This allows a single end to * be tested w/the other disabled, should that requirement ever arise. */ -stat_t cm_test_soft_limits(float target[]) { +stat_t mach_test_soft_limits(float target[]) { #ifdef SOFT_LIMIT_ENABLE for (int axis = 0; axis < AXES; axis++) { - if (!cm.homed[axis]) continue; // don't test axes that are not homed + if (!mach.homed[axis]) continue; // don't test axes that are not homed - if (fp_EQ(cm.a[axis].travel_min, cm.a[axis].travel_max)) continue; + if (fp_EQ(mach.a[axis].travel_min, mach.a[axis].travel_max)) continue; - if (cm.a[axis].travel_min > DISABLE_SOFT_LIMIT && - target[axis] < cm.a[axis].travel_min) + if (mach.a[axis].travel_min > DISABLE_SOFT_LIMIT && + target[axis] < mach.a[axis].travel_min) return STAT_SOFT_LIMIT_EXCEEDED; - if (cm.a[axis].travel_max > DISABLE_SOFT_LIMIT && - target[axis] > cm.a[axis].travel_max) + if (mach.a[axis].travel_max > DISABLE_SOFT_LIMIT && + target[axis] > mach.a[axis].travel_max) return STAT_SOFT_LIMIT_EXCEEDED; } #endif @@ -638,24 +645,24 @@ stat_t cm_test_soft_limits(float target[]) { void machine_init() { // Init 1/jerk for (uint8_t axis = 0; axis < AXES; axis++) - cm.a[axis].recip_jerk = 1 / (cm.a[axis].jerk_max * JERK_MULTIPLIER); + mach.a[axis].recip_jerk = 1 / (mach.a[axis].jerk_max * JERK_MULTIPLIER); // Set gcode defaults - cm_set_units_mode(GCODE_DEFAULT_UNITS); - cm_set_coord_system(GCODE_DEFAULT_COORD_SYSTEM); - cm_set_plane(GCODE_DEFAULT_PLANE); - cm_set_path_control(GCODE_DEFAULT_PATH_CONTROL); - cm_set_distance_mode(GCODE_DEFAULT_DISTANCE_MODE); - cm_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); // always the default + mach_set_units_mode(GCODE_DEFAULT_UNITS); + mach_set_coord_system(GCODE_DEFAULT_COORD_SYSTEM); + mach_set_plane(GCODE_DEFAULT_PLANE); + mach_set_path_control(GCODE_DEFAULT_PATH_CONTROL); + mach_set_distance_mode(GCODE_DEFAULT_DISTANCE_MODE); + mach_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); // always the default // Sub-system inits - cm_spindle_init(); + mach_spindle_init(); coolant_init(); } /// Alarm state; send an exception report and stop processing input -stat_t cm_alarm(const char *location, stat_t code) { +stat_t mach_alarm(const char *location, stat_t code) { status_message_P(location, STAT_LEVEL_ERROR, code, "ALARM"); estop_trigger(); return code; @@ -663,10 +670,10 @@ stat_t cm_alarm(const char *location, stat_t code) { /// Clear soft alarm -stat_t cm_clear() { - if (cm.cycle_state == CYCLE_OFF) - cm.machine_state = MACHINE_PROGRAM_STOP; - else cm.machine_state = MACHINE_CYCLE; +stat_t mach_clear() { + if (mach.cycle_state == CYCLE_OFF) + mach.machine_state = MACHINE_PROGRAM_STOP; + else mach.machine_state = MACHINE_CYCLE; return STAT_OK; } @@ -678,15 +685,17 @@ stat_t cm_clear() { // These functions assume input validation occurred upstream. /// G17, G18, G19 select axis plane -void cm_set_plane(cmPlane_t plane) {cm.gm.select_plane = plane;} +void mach_set_plane(machPlane_t plane) {mach.gm.select_plane = plane;} /// G20, G21 -void cm_set_units_mode(cmUnitsMode_t mode) {cm.gm.units_mode = mode;} +void mach_set_units_mode(machUnitsMode_t mode) {mach.gm.units_mode = mode;} /// G90, G91 -void cm_set_distance_mode(cmDistanceMode_t mode) {cm.gm.distance_mode = mode;} +void mach_set_distance_mode(machDistanceMode_t mode) { + mach.gm.distance_mode = mode; +} /* G10 L2 Pn, delayed persistence @@ -695,17 +704,17 @@ void cm_set_distance_mode(cmDistanceMode_t mode) {cm.gm.distance_mode = mode;} * use $g54x - $g59c config functions to change offsets. * * It also does not reset the work_offsets which may be - * accomplished by calling cm_set_work_offsets() immediately + * accomplished by calling mach_set_work_offsets() immediately * afterwards. */ -void cm_set_coord_offsets(cmCoordSystem_t coord_system, float offset[], +void mach_set_coord_offsets(machCoordSystem_t coord_system, float offset[], float flag[]) { if (coord_system < G54 || coord_system > COORD_SYSTEM_MAX) return; // you can't set G53 for (int axis = 0; axis < AXES; axis++) if (fp_TRUE(flag[axis])) - cm.offset[coord_system][axis] = TO_MILLIMETERS(offset[axis]); + mach.offset[coord_system][axis] = TO_MILLIMETERS(offset[axis]); } @@ -713,8 +722,8 @@ void cm_set_coord_offsets(cmCoordSystem_t coord_system, float offset[], // (synchronous) /// G54-G59 -void cm_set_coord_system(cmCoordSystem_t coord_system) { - cm.gm.coord_system = coord_system; +void mach_set_coord_system(machCoordSystem_t coord_system) { + mach.gm.coord_system = coord_system; // pass coordinate system in value[0] element float value[AXES] = {coord_system}; @@ -729,11 +738,11 @@ static void _exec_offset(float *value, float *flag) { float offsets[AXES]; for (int axis = 0; axis < AXES; axis++) - offsets[axis] = cm.offset[coord_system][axis] + - cm.origin_offset[axis] * (cm.origin_offset_enable ? 1 : 0); + offsets[axis] = mach.offset[coord_system][axis] + + mach.origin_offset[axis] * (mach.origin_offset_enable ? 1 : 0); mp_set_runtime_work_offset(offsets); - cm_set_work_offsets(); // set work offsets in the Gcode model + mach_set_work_offsets(); // set work offsets in the Gcode model } @@ -752,12 +761,12 @@ static void _exec_offset(float *value, float *flag) { * only be called during initialization sequences and during cycles * (such as homing cycles) when you know there are no more moves in * the planner and that all motion has stopped. Use - * cm_get_runtime_busy() to be sure the system is quiescent. + * mach_get_runtime_busy() to be sure the system is quiescent. */ -void cm_set_position(int axis, float position) { +void mach_set_position(int axis, float position) { // TODO: Interlock involving runtime_busy test - cm.position[axis] = position; - cm.ms.target[axis] = position; + mach.position[axis] = position; + mach.ms.target[axis] = position; mp_set_planner_position(axis, position); mp_set_runtime_position(axis, position); mp_set_steps_to_runtime_position(); @@ -778,14 +787,14 @@ void cm_set_position(int axis, float position) { * recording done by the encoders. At that point any axis that is set * is also marked as homed. */ -void cm_set_absolute_origin(float origin[], float flag[]) { +void mach_set_absolute_origin(float origin[], float flag[]) { float value[AXES]; for (int axis = 0; axis < AXES; axis++) if (fp_TRUE(flag[axis])) { value[axis] = TO_MILLIMETERS(origin[axis]); - cm.position[axis] = value[axis]; // set model position - cm.ms.target[axis] = value[axis]; // reset model target + mach.position[axis] = value[axis]; // set model position + mach.ms.target[axis] = value[axis]; // reset model target mp_set_planner_position(axis, value[axis]); // set mm position } @@ -797,7 +806,7 @@ static void _exec_absolute_origin(float *value, float *flag) { for (int axis = 0; axis < AXES; axis++) if (fp_TRUE(flag[axis])) { mp_set_runtime_position(axis, value[axis]); - cm.homed[axis] = true; // G28.3 is not considered homed until here + mach.homed[axis] = true; // G28.3 is not considered homed until here } mp_set_steps_to_runtime_position(); @@ -809,45 +818,45 @@ static void _exec_absolute_origin(float *value, float *flag) { */ /// G92 -void cm_set_origin_offsets(float offset[], float flag[]) { +void mach_set_origin_offsets(float offset[], float flag[]) { // set offsets in the Gcode model extended context - cm.origin_offset_enable = true; + mach.origin_offset_enable = true; for (int axis = 0; axis < AXES; axis++) if (fp_TRUE(flag[axis])) - cm.origin_offset[axis] = cm.position[axis] - - cm.offset[cm.gm.coord_system][axis] - TO_MILLIMETERS(offset[axis]); + mach.origin_offset[axis] = mach.position[axis] - + mach.offset[mach.gm.coord_system][axis] - TO_MILLIMETERS(offset[axis]); // now pass the offset to the callback - setting the coordinate system also // applies the offsets // pass coordinate system in value[0] element - float value[AXES] = {cm.gm.coord_system}; + float value[AXES] = {mach.gm.coord_system}; mp_queue_command(_exec_offset, value, value); // second vector is not used } /// G92.1 -void cm_reset_origin_offsets() { - cm.origin_offset_enable = false; +void mach_reset_origin_offsets() { + mach.origin_offset_enable = false; for (int axis = 0; axis < AXES; axis++) - cm.origin_offset[axis] = 0; + mach.origin_offset[axis] = 0; - float value[AXES] = {cm.gm.coord_system}; + float value[AXES] = {mach.gm.coord_system}; mp_queue_command(_exec_offset, value, value); } /// G92.2 -void cm_suspend_origin_offsets() { - cm.origin_offset_enable = false; - float value[AXES] = {cm.gm.coord_system}; +void mach_suspend_origin_offsets() { + mach.origin_offset_enable = false; + float value[AXES] = {mach.gm.coord_system}; mp_queue_command(_exec_offset, value, value); } /// G92.3 -void cm_resume_origin_offsets() { - cm.origin_offset_enable = true; - float value[AXES] = {cm.gm.coord_system}; +void mach_resume_origin_offsets() { + mach.origin_offset_enable = true; + float value[AXES] = {mach.gm.coord_system}; mp_queue_command(_exec_offset, value, value); } @@ -855,62 +864,62 @@ void cm_resume_origin_offsets() { // Free Space Motion (4.3.4) /// G0 linear rapid -stat_t cm_straight_traverse(float target[], float flags[]) { - cm.gm.motion_mode = MOTION_MODE_STRAIGHT_TRAVERSE; - cm_set_model_target(target, flags); +stat_t mach_straight_traverse(float target[], float flags[]) { + mach.gm.motion_mode = MOTION_MODE_STRAIGHT_TRAVERSE; + mach_set_model_target(target, flags); // test soft limits - stat_t status = cm_test_soft_limits(cm.ms.target); + stat_t status = mach_test_soft_limits(mach.ms.target); if (status != STAT_OK) return CM_ALARM(status); // prep and plan the move - cm_set_work_offsets(&cm.gm); // capture fully resolved offsets to the state - cm_cycle_start(); // required for homing & other cycles - cm.ms.line = cm.gm.line; // copy line number - mp_aline(&cm.ms); // send the move to the planner - cm_finalize_move(); + mach_set_work_offsets(&mach.gm); // capture fully resolved offsets to state + mach_cycle_start(); // required for homing & other cycles + mach.ms.line = mach.gm.line; // copy line number + mp_aline(&mach.ms); // send the move to the planner + mach_finalize_move(); return STAT_OK; } /// G28.1 -void cm_set_g28_position() {copy_vector(cm.g28_position, cm.position);} +void mach_set_g28_position() {copy_vector(mach.g28_position, mach.position);} /// G28 -stat_t cm_goto_g28_position(float target[], float flags[]) { - cm_set_absolute_override(true); +stat_t mach_goto_g28_position(float target[], float flags[]) { + mach_set_absolute_override(true); // move through intermediate point, or skip - cm_straight_traverse(target, flags); + mach_straight_traverse(target, flags); // make sure you have an available buffer mp_wait_for_buffer(); // execute actual stored move float f[] = {1, 1, 1, 1, 1, 1}; - return cm_straight_traverse(cm.g28_position, f); + return mach_straight_traverse(mach.g28_position, f); } /// G30.1 -void cm_set_g30_position() {copy_vector(cm.g30_position, cm.position);} +void mach_set_g30_position() {copy_vector(mach.g30_position, mach.position);} /// G30 -stat_t cm_goto_g30_position(float target[], float flags[]) { - cm_set_absolute_override(true); +stat_t mach_goto_g30_position(float target[], float flags[]) { + mach_set_absolute_override(true); // move through intermediate point, or skip - cm_straight_traverse(target, flags); + mach_straight_traverse(target, flags); // make sure you have an available buffer mp_wait_for_buffer(); // execute actual stored move float f[] = {1, 1, 1, 1, 1, 1}; - return cm_straight_traverse(cm.g30_position, f); + return mach_straight_traverse(mach.g30_position, f); } @@ -918,50 +927,54 @@ stat_t cm_goto_g30_position(float target[], float flags[]) { /// F parameter /// Normalize feed rate to mm/min or to minutes if in inverse time mode -void cm_set_feed_rate(float feed_rate) { - if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE) +void mach_set_feed_rate(float feed_rate) { + if (mach.gm.feed_rate_mode == INVERSE_TIME_MODE) // normalize to minutes (active for this gcode block only) - cm.gm.feed_rate = 1 / feed_rate; + mach.gm.feed_rate = 1 / feed_rate; - else cm.gm.feed_rate = TO_MILLIMETERS(feed_rate); + else mach.gm.feed_rate = TO_MILLIMETERS(feed_rate); } -/// G93, G94 See cmFeedRateMode -void cm_set_feed_rate_mode(cmFeedRateMode_t mode) {cm.gm.feed_rate_mode = mode;} +/// G93, G94 See machFeedRateMode +void mach_set_feed_rate_mode(machFeedRateMode_t mode) { + mach.gm.feed_rate_mode = mode; +} /// G61, G61.1, G64 -void cm_set_path_control(cmPathControlMode_t mode) {cm.gm.path_control = mode;} +void mach_set_path_control(machPathControlMode_t mode) { + mach.gm.path_control = mode; +} // Machining Functions (4.3.6) See arc.c /// G4, P parameter (seconds) -stat_t cm_dwell(float seconds) { +stat_t mach_dwell(float seconds) { return mp_dwell(seconds); } /// G1 -stat_t cm_straight_feed(float target[], float flags[]) { +stat_t mach_straight_feed(float target[], float flags[]) { // trap zero feed rate condition - if (cm.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(cm.gm.feed_rate)) + if (mach.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(mach.gm.feed_rate)) return STAT_GCODE_FEEDRATE_NOT_SPECIFIED; - cm.gm.motion_mode = MOTION_MODE_STRAIGHT_FEED; - cm_set_model_target(target, flags); + mach.gm.motion_mode = MOTION_MODE_STRAIGHT_FEED; + mach_set_model_target(target, flags); // test soft limits - stat_t status = cm_test_soft_limits(cm.ms.target); + stat_t status = mach_test_soft_limits(mach.ms.target); if (status != STAT_OK) return CM_ALARM(status); // prep and plan the move - cm_set_work_offsets(&cm.gm); // capture the fully resolved offsets to state - cm_cycle_start(); // required for homing & other cycles - cm.ms.line = cm.gm.line; // copy line number - status = mp_aline(&cm.ms); // send the move to the planner - cm_finalize_move(); + mach_set_work_offsets(&mach.gm); // capture fully resolved offsets to state + mach_cycle_start(); // required for homing & other cycles + mach.ms.line = mach.gm.line; // copy line number + status = mp_aline(&mach.ms); // send the move to the planner + mach_finalize_move(); return status; } @@ -976,51 +989,51 @@ stat_t cm_straight_feed(float target[], float flags[]) { */ /// T parameter -void cm_select_tool(uint8_t tool_select) { +void mach_select_tool(uint8_t tool_select) { float value[AXES] = {tool_select}; mp_queue_command(_exec_select_tool, value, value); } static void _exec_select_tool(float *value, float *flag) { - cm.gm.tool_select = value[0]; + mach.gm.tool_select = value[0]; } /// M6 This might become a complete tool change cycle -void cm_change_tool(uint8_t tool_change) { - float value[AXES] = {cm.gm.tool_select}; +void mach_change_tool(uint8_t tool_change) { + float value[AXES] = {mach.gm.tool_select}; mp_queue_command(_exec_change_tool, value, value); } static void _exec_change_tool(float *value, float *flag) { - cm.gm.tool = (uint8_t)value[0]; + mach.gm.tool = (uint8_t)value[0]; } // Miscellaneous Functions (4.3.9) /// M7 -void cm_mist_coolant_control(bool mist_coolant) { +void mach_mist_coolant_control(bool mist_coolant) { float value[AXES] = {mist_coolant}; mp_queue_command(_exec_mist_coolant_control, value, value); } static void _exec_mist_coolant_control(float *value, float *flag) { - coolant_set_mist(cm.gm.mist_coolant = value[0]); + coolant_set_mist(mach.gm.mist_coolant = value[0]); } /// M8, M9 -void cm_flood_coolant_control(bool flood_coolant) { +void mach_flood_coolant_control(bool flood_coolant) { float value[AXES] = {flood_coolant}; mp_queue_command(_exec_flood_coolant_control, value, value); } static void _exec_flood_coolant_control(float *value, float *flag) { - cm.gm.flood_coolant = value[0]; + mach.gm.flood_coolant = value[0]; coolant_set_flood(value[0]); if (!value[0]) coolant_set_mist(false); // M9 special function @@ -1033,59 +1046,59 @@ static void _exec_flood_coolant_control(float *value, float *flag) { */ /// M48, M49 -void cm_override_enables(bool flag) { - cm.gm.feed_rate_override_enable = flag; - cm.gm.traverse_override_enable = flag; - cm.gm.spindle_override_enable = flag; +void mach_override_enables(bool flag) { + mach.gm.feed_rate_override_enable = flag; + mach.gm.traverse_override_enable = flag; + mach.gm.spindle_override_enable = flag; } /// M50 -void cm_feed_rate_override_enable(bool flag) { - if (fp_TRUE(cm.gf.parameter) && fp_ZERO(cm.gn.parameter)) - cm.gm.feed_rate_override_enable = false; - else cm.gm.feed_rate_override_enable = true; +void mach_feed_rate_override_enable(bool flag) { + if (fp_TRUE(mach.gf.parameter) && fp_ZERO(mach.gn.parameter)) + mach.gm.feed_rate_override_enable = false; + else mach.gm.feed_rate_override_enable = true; } /// M50.1 -void cm_feed_rate_override_factor(bool flag) { - cm.gm.feed_rate_override_enable = flag; - cm.gm.feed_rate_override_factor = cm.gn.parameter; +void mach_feed_rate_override_factor(bool flag) { + mach.gm.feed_rate_override_enable = flag; + mach.gm.feed_rate_override_factor = mach.gn.parameter; } /// M50.2 -void cm_traverse_override_enable(bool flag) { - if (fp_TRUE(cm.gf.parameter) && fp_ZERO(cm.gn.parameter)) - cm.gm.traverse_override_enable = false; - else cm.gm.traverse_override_enable = true; +void mach_traverse_override_enable(bool flag) { + if (fp_TRUE(mach.gf.parameter) && fp_ZERO(mach.gn.parameter)) + mach.gm.traverse_override_enable = false; + else mach.gm.traverse_override_enable = true; } /// M51 -void cm_traverse_override_factor(bool flag) { - cm.gm.traverse_override_enable = flag; - cm.gm.traverse_override_factor = cm.gn.parameter; +void mach_traverse_override_factor(bool flag) { + mach.gm.traverse_override_enable = flag; + mach.gm.traverse_override_factor = mach.gn.parameter; } /// M51.1 -void cm_spindle_override_enable(bool flag) { - if (fp_TRUE(cm.gf.parameter) && fp_ZERO(cm.gn.parameter)) - cm.gm.spindle_override_enable = false; - else cm.gm.spindle_override_enable = true; +void mach_spindle_override_enable(bool flag) { + if (fp_TRUE(mach.gf.parameter) && fp_ZERO(mach.gn.parameter)) + mach.gm.spindle_override_enable = false; + else mach.gm.spindle_override_enable = true; } /// M50.1 -void cm_spindle_override_factor(bool flag) { - cm.gm.spindle_override_enable = flag; - cm.gm.spindle_override_factor = cm.gn.parameter; +void mach_spindle_override_factor(bool flag) { + mach.gm.spindle_override_enable = flag; + mach.gm.spindle_override_factor = mach.gn.parameter; } -void cm_message(const char *message) { +void mach_message(const char *message) { status_message_P(0, STAT_LEVEL_INFO, STAT_OK, PSTR("%s"), message); } @@ -1095,14 +1108,14 @@ void cm_message(const char *message) { * This group implements stop, start, end, and hold. * It is extended beyond the NIST spec to handle various situations. * - * cm_program_stop and cm_optional_program_stop are synchronous Gcode + * mach_program_stop and mach_optional_program_stop are synchronous Gcode * commands that are received through the interpreter. They cause all motion * to stop at the end of the current command, including spindle motion. * * Note that the stop occurs at the end of the immediately preceding command * (i.e. the stop is queued behind the last command). * - * cm_program_end is a stop that also resets the machine to initial state + * mach_program_end is a stop that also resets the machine to initial state */ /* Feedholds, queue flushes and cycles starts are all related. The request @@ -1131,40 +1144,42 @@ void cm_message(const char *message) { /// Initiate a feedhold right now -void cm_request_feedhold() {cm.feedhold_requested = true;} -void cm_request_queue_flush() {cm.queue_flush_requested = true;} -void cm_request_cycle_start() {cm.cycle_start_requested = true;} +void mach_request_feedhold() {mach.feedhold_requested = true;} +void mach_request_queue_flush() {mach.queue_flush_requested = true;} +void mach_request_cycle_start() {mach.cycle_start_requested = true;} /// Process feedholds, cycle starts & queue flushes -void cm_feedhold_callback() { - if (cm.feedhold_requested) { - if (cm.motion_state == MOTION_RUN && cm.hold_state == FEEDHOLD_OFF) { - cm_set_motion_state(MOTION_HOLD); - cm.hold_state = FEEDHOLD_SYNC; // invokes hold from aline execution +void mach_feedhold_callback() { + if (mach.feedhold_requested) { + if (mach.motion_state == MOTION_RUN && mach.hold_state == FEEDHOLD_OFF) { + mach_set_motion_state(MOTION_HOLD); + mach.hold_state = FEEDHOLD_SYNC; // invokes hold from aline execution } - cm.feedhold_requested = false; + mach.feedhold_requested = false; } - if (cm.queue_flush_requested) { - if ((cm.motion_state == MOTION_STOP || - (cm.motion_state == MOTION_HOLD && cm.hold_state == FEEDHOLD_HOLD)) && - !cm_get_runtime_busy()) { - cm.queue_flush_requested = false; - cm_queue_flush(); + if (mach.queue_flush_requested) { + if ((mach.motion_state == MOTION_STOP || + (mach.motion_state == MOTION_HOLD && + mach.hold_state == FEEDHOLD_HOLD)) && + !mach_get_runtime_busy()) { + mach.queue_flush_requested = false; + mach_queue_flush(); } } bool processing = - cm.hold_state == FEEDHOLD_SYNC || - cm.hold_state == FEEDHOLD_PLAN || - cm.hold_state == FEEDHOLD_DECEL; - - if (cm.cycle_start_requested && !cm.queue_flush_requested && !processing) { - cm.cycle_start_requested = false; - cm.hold_state = FEEDHOLD_END_HOLD; - cm_cycle_start(); + mach.hold_state == FEEDHOLD_SYNC || + mach.hold_state == FEEDHOLD_PLAN || + mach.hold_state == FEEDHOLD_DECEL; + + if (mach.cycle_start_requested && !mach.queue_flush_requested && + !processing) { + mach.cycle_start_requested = false; + mach.hold_state = FEEDHOLD_END_HOLD; + mach_cycle_start(); mp_end_hold(); } @@ -1172,15 +1187,15 @@ void cm_feedhold_callback() { } -stat_t cm_queue_flush() { - if (cm_get_runtime_busy()) return STAT_COMMAND_NOT_ACCEPTED; +stat_t mach_queue_flush() { + if (mach_get_runtime_busy()) return STAT_COMMAND_NOT_ACCEPTED; mp_flush_planner(); // flush planner queue // Note: The following uses low-level mp calls for absolute position. for (int axis = 0; axis < AXES; axis++) // set mm from mr - cm_set_position(axis, mp_get_runtime_absolute_position(axis)); + mach_set_position(axis, mp_get_runtime_absolute_position(axis)); float value[AXES] = {MACHINE_PROGRAM_STOP}; _exec_program_finalize(value, value); // finalize now, not later @@ -1191,7 +1206,7 @@ stat_t cm_queue_flush() { /* Program and cycle state functions * - * cm_program_end() implements M2 and M30 + * mach_program_end() implements M2 and M30 * The END behaviors are defined by NIST 3.6.1 are: * 1. Axis offsets are set to zero (like G92.2) and origin offsets are set * to the default (like G54) @@ -1204,7 +1219,7 @@ stat_t cm_queue_flush() { * 8. The current motion mode is set to G_1 (like G1) * 9. Coolant is turned off (like M9) * - * cm_program_end() implments things slightly differently: + * mach_program_end() implments things slightly differently: * 1. Axis offsets are set to G92.1 CANCEL offsets * (instead of using G92.2 SUSPEND Offsets) * Set default coordinate system (uses $gco, not G54) @@ -1220,41 +1235,41 @@ stat_t cm_queue_flush() { * + Default INCHES or MM units mode is restored ($gun) */ static void _exec_program_finalize(float *value, float *flag) { - cm.machine_state = (uint8_t)value[0]; - cm_set_motion_state(MOTION_STOP); - if (cm.cycle_state == CYCLE_MACHINING) - cm.cycle_state = CYCLE_OFF; // don't end cycle if homing, probing, etc. + mach.machine_state = (uint8_t)value[0]; + mach_set_motion_state(MOTION_STOP); + if (mach.cycle_state == CYCLE_MACHINING) + mach.cycle_state = CYCLE_OFF; // don't end cycle if homing, probing, etc - cm.hold_state = FEEDHOLD_OFF; // end feedhold (if in feed hold) - cm.cycle_start_requested = false; // cancel any pending cycle start request - mp_zero_segment_velocity(); // for reporting purposes + mach.hold_state = FEEDHOLD_OFF; // end feedhold (if in feed hold) + mach.cycle_start_requested = false; // cancel any pending cycle start request + mp_zero_segment_velocity(); // for reporting purposes // perform the following resets if it's a program END - if (cm.machine_state == MACHINE_PROGRAM_END) { - cm_reset_origin_offsets(); // G92.1 - we do G91.1 instead of G92.2 - cm_set_coord_system(GCODE_DEFAULT_COORD_SYSTEM); - cm_set_plane(GCODE_DEFAULT_PLANE); - cm_set_distance_mode(GCODE_DEFAULT_DISTANCE_MODE); - cm_spindle_control(SPINDLE_OFF); // M5 - cm_flood_coolant_control(false); // M9 - cm_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); // G94 - cm_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); + if (mach.machine_state == MACHINE_PROGRAM_END) { + mach_reset_origin_offsets(); // G92.1 - we do G91.1 instead of G92.2 + mach_set_coord_system(GCODE_DEFAULT_COORD_SYSTEM); + mach_set_plane(GCODE_DEFAULT_PLANE); + mach_set_distance_mode(GCODE_DEFAULT_DISTANCE_MODE); + mach_spindle_control(SPINDLE_OFF); // M5 + mach_flood_coolant_control(false); // M9 + mach_set_feed_rate_mode(UNITS_PER_MINUTE_MODE); // G94 + mach_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); } } /// Do a cycle start right now -void cm_cycle_start() { - cm.machine_state = MACHINE_CYCLE; +void mach_cycle_start() { + mach.machine_state = MACHINE_CYCLE; // don't (re)start homing, probe or other canned cycles - if (cm.cycle_state == CYCLE_OFF) cm.cycle_state = CYCLE_MACHINING; + if (mach.cycle_state == CYCLE_OFF) mach.cycle_state = CYCLE_MACHINING; } /// Do a cycle end right now -void cm_cycle_end() { - if (cm.cycle_state != CYCLE_OFF) { +void mach_cycle_end() { + if (mach.cycle_state != CYCLE_OFF) { float value[AXES] = {MACHINE_PROGRAM_STOP}; _exec_program_finalize(value, value); } @@ -1263,28 +1278,28 @@ void cm_cycle_end() { /// M0 Queue a program stop -void cm_program_stop() { +void mach_program_stop() { float value[AXES] = {MACHINE_PROGRAM_STOP}; mp_queue_command(_exec_program_finalize, value, value); } /// M1 -void cm_optional_program_stop() { +void mach_optional_program_stop() { float value[AXES] = {MACHINE_PROGRAM_STOP}; mp_queue_command(_exec_program_finalize, value, value); } /// M2, M30 -void cm_program_end() { +void mach_program_end() { float value[AXES] = {MACHINE_PROGRAM_END}; mp_queue_command(_exec_program_finalize, value, value); } /// return ASCII char for axis given the axis number -char cm_get_axis_char(int8_t axis) { +char mach_get_axis_char(int8_t axis) { char axis_char[] = "XYZABC"; if (axis < 0 || axis > AXES) return ' '; return axis_char[axis]; diff --git a/src/machine.h b/src/machine.h index 300c942..4eceef4 100644 --- a/src/machine.h +++ b/src/machine.h @@ -36,7 +36,7 @@ #include -#define TO_MILLIMETERS(a) (cm.gm.units_mode == INCHES ? (a) * MM_PER_INCH : a) +#define TO_MILLIMETERS(a) (mach.gm.units_mode == INCHES ? (a) * MM_PER_INCH : a) #define DISABLE_SOFT_LIMIT -1000000 @@ -46,9 +46,9 @@ * * The following main variables track 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 + * - mach.machine_state - overall state of machine and program execution + * - mach.cycle_state - what cycle the machine is executing (or none) + * - mach.motion_state - state of movement * * Allowed states and combined states: * @@ -83,7 +83,7 @@ typedef enum { COMBINED_CYCLE, // machine is running (cycling) COMBINED_HOMING, // homing is treated as a cycle COMBINED_SHUTDOWN, // machine in hard alarm state (shutdown) -} cmCombinedState_t; +} machCombinedState_t; typedef enum { @@ -94,7 +94,7 @@ typedef enum { MACHINE_PROGRAM_END, // program end MACHINE_CYCLE, // machine is running (cycling) MACHINE_SHUTDOWN, // machine in hard alarm state (shutdown) -} cmMachineState_t; +} machMachineState_t; typedef enum { @@ -102,14 +102,14 @@ typedef enum { CYCLE_MACHINING, // in normal machining cycle CYCLE_PROBE, // in probe cycle CYCLE_HOMING, // homing is treated as a specialized cycle -} cmCycleState_t; +} machCycleState_t; typedef enum { MOTION_STOP, // motion has stopped MOTION_RUN, // machine is in motion MOTION_HOLD // feedhold in progress -} cmMotionState_t; +} machMotionState_t; typedef enum { // feedhold_state machine @@ -119,21 +119,21 @@ typedef enum { // feedhold_state machine FEEDHOLD_DECEL, // decelerate to hold point FEEDHOLD_HOLD, // holding FEEDHOLD_END_HOLD // end hold (transient state to OFF) -} cmFeedholdState_t; +} machFeedholdState_t; -typedef enum { // applies to cm.homing_state +typedef enum { // applies to mach.homing_state HOMING_NOT_HOMED, // machine is not homed (0=false) HOMING_HOMED, // machine is homed (1=true) HOMING_WAITING // machine waiting to be homed -} cmHomingState_t; +} machHomingState_t; -typedef enum { // applies to cm.probe_state +typedef enum { // applies to mach.probe_state PROBE_FAILED, // probe reached endpoint without triggering - PROBE_SUCCEEDED, // probe was triggered, cm.probe_results has position + PROBE_SUCCEEDED, // probe was triggered, mach.probe_results has position PROBE_WAITING, // probe is waiting to be started -} cmProbeState_t; +} machProbeState_t; /* The difference between NextAction and MotionMode is that NextAction is @@ -158,7 +158,7 @@ typedef enum { NEXT_ACTION_RESUME_ORIGIN_OFFSETS, // G92.3 NEXT_ACTION_DWELL, // G4 NEXT_ACTION_STRAIGHT_PROBE // G38.2 -} cmNextAction_t; +} machNextAction_t; typedef enum { // G Modal Group 1 @@ -177,7 +177,7 @@ typedef enum { // G Modal Group 1 MOTION_MODE_CANNED_CYCLE_87, // G87 - back boring MOTION_MODE_CANNED_CYCLE_88, // G88 - boring, spindle stop, manual out MOTION_MODE_CANNED_CYCLE_89, // G89 - boring, dwell, feed out -} cmMotionMode_t; +} machMotionMode_t; typedef enum { // Used for detecting gcode errors. See NIST section 3.4 @@ -197,7 +197,7 @@ typedef enum { // Used for detecting gcode errors. See NIST section 3.4 MODAL_GROUP_M7, // {M3,M4,M5} spindle turning MODAL_GROUP_M8, // {M7,M8,M9} coolant MODAL_GROUP_M9, // {M48,M49} speed/feed override switches -} cmModalGroup_t; +} machModalGroup_t; #define MODAL_GROUP_COUNT (MODAL_GROUP_M9 + 1) @@ -209,14 +209,14 @@ typedef enum { // plane - translates to: PLANE_XY, // G17 X Y Z PLANE_XZ, // G18 X Z Y PLANE_YZ // G19 Y Z X -} cmPlane_t; +} machPlane_t; typedef enum { INCHES, // G20 MILLIMETERS, // G21 DEGREES // ABC axes (this value used for displays only) -} cmUnitsMode_t; +} machUnitsMode_t; typedef enum { @@ -227,7 +227,7 @@ typedef enum { G57, // G57 coordinate system G58, // G58 coordinate system G59 // G59 coordinate system -} cmCoordSystem_t; +} machCoordSystem_t; #define COORD_SYSTEM_MAX G59 // set this manually to the last one @@ -237,20 +237,20 @@ typedef enum { PATH_EXACT_PATH, PATH_EXACT_STOP, // G61.1 - stops at all corners PATH_CONTINUOUS // G64 and typically the default mode -} cmPathControlMode_t; +} machPathControlMode_t; typedef enum { ABSOLUTE_MODE, // G90 INCREMENTAL_MODE // G91 -} cmDistanceMode_t; +} machDistanceMode_t; typedef enum { INVERSE_TIME_MODE, // G93 UNITS_PER_MINUTE_MODE, // G94 UNITS_PER_REVOLUTION_MODE // G95 (unimplemented) -} cmFeedRateMode_t; +} machFeedRateMode_t; typedef enum { @@ -258,13 +258,13 @@ typedef enum { ORIGIN_OFFSET_CANCEL, // G92.1 - zero out origin offsets ORIGIN_OFFSET_SUSPEND, // G92.2 - do not apply offsets, but preserve values ORIGIN_OFFSET_RESUME // G92.3 - resume application of the suspended offsets -} cmOriginOffset_t; +} machOriginOffset_t; typedef enum { PROGRAM_STOP, PROGRAM_END -} cmProgramFlow_t; +} machProgramFlow_t; /// spindle state settings @@ -272,7 +272,7 @@ typedef enum { SPINDLE_OFF, SPINDLE_CW, SPINDLE_CCW -} cmSpindleMode_t; +} machSpindleMode_t; /// mist and flood coolant states @@ -281,24 +281,24 @@ typedef enum { COOLANT_ON, // request coolant on or indicate both coolants are on COOLANT_MIST, // indicates mist coolant on COOLANT_FLOOD // indicates flood coolant on -} cmCoolantState_t; +} machCoolantState_t; /// used for spindle and arc dir typedef enum { DIRECTION_CW, DIRECTION_CCW -} cmDirection_t; +} machDirection_t; -/// axis modes (ordered: see _cm_get_feed_time()) +/// axis modes (ordered: see _mach_get_feed_time()) typedef enum { AXIS_DISABLED, // kill axis AXIS_STANDARD, // axis in coordinated motion w/standard behaviors AXIS_INHIBITED, // axis is computed but not activated AXIS_RADIUS, // rotary axis calibrated to circumference AXIS_MODE_MAX -} cmAxisMode_t; // ordering must be preserved. +} machAxisMode_t; // ordering must be preserved. /* Gcode model - The following GCodeModel/GCodeInput structs are used: @@ -307,7 +307,7 @@ typedef enum { * state model in normalized, canonical form. All values are unit * converted (to mm) and in the machine coordinate system * (absolute coordinate system). Gm is owned by the machine layer and - * should be accessed only through cm_ routines. + * should be accessed only through mach_ routines. * * - gn is used by the gcode interpreter and is re-initialized for * each gcode block.It accepts data in the new gcode block in the @@ -316,7 +316,7 @@ typedef enum { * 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[] + * data that has changed in gn during the parse. mach.gf.target[] * values are also used by the machine during * set_target(). */ @@ -331,38 +331,38 @@ typedef struct { /// Gcode model state -typedef struct GCodeState { +typedef struct { uint32_t line; // Gcode block line number uint8_t tool; // Tool after T and M6 uint8_t tool_select; // T - sets this value float feed_rate; // F - in mm/min or inverse time mode - cmFeedRateMode_t feed_rate_mode; + machFeedRateMode_t feed_rate_mode; float feed_rate_override_factor; // 1.0000 x F feed rate. bool feed_rate_override_enable; // M48, M49 float traverse_override_factor; // 1.0000 x traverse rate bool traverse_override_enable; float spindle_speed; // in RPM - cmSpindleMode_t spindle_mode; + machSpindleMode_t spindle_mode; float spindle_override_factor; // 1.0000 x S spindle speed bool spindle_override_enable; // true = override enabled - cmMotionMode_t motion_mode; // Group 1 modal motion - cmPlane_t select_plane; // G17, G18, G19 - cmUnitsMode_t units_mode; // G20, G21 - cmCoordSystem_t coord_system; // G54-G59 - select coordinate system 1-9 + machMotionMode_t motion_mode; // Group 1 modal motion + machPlane_t select_plane; // G17, G18, G19 + machUnitsMode_t units_mode; // G20, G21 + machCoordSystem_t coord_system; // G54-G59 - select coordinate system 1-9 bool absolute_override; // G53 true = move in machine coordinates - cmPathControlMode_t path_control; // G61 - cmDistanceMode_t distance_mode; // G91 - cmDistanceMode_t arc_distance_mode; // G91.1 + machPathControlMode_t path_control; // G61 + machDistanceMode_t distance_mode; // G91 + machDistanceMode_t arc_distance_mode; // G91.1 bool mist_coolant; // true = mist on (M7), false = off (M9) bool flood_coolant; // true = flood on (M8), false = off (M9) - cmNextAction_t next_action; // handles G group 1 moves & non-modals - cmProgramFlow_t program_flow; // used only by the gcode_parser + machNextAction_t next_action; // handles G group 1 moves & non-modals + machProgramFlow_t program_flow; // used only by the gcode_parser // unimplemented gcode parameters // float cutter_radius; // D - cutter radius compensation (0 is off) @@ -380,8 +380,8 @@ typedef struct GCodeState { } GCodeState_t; -typedef struct cmAxis { - cmAxisMode_t axis_mode; +typedef struct { + machAxisMode_t axis_mode; float feedrate_max; // max velocity in mm/min or deg/min float velocity_max; // max velocity in mm/min or deg/min float travel_max; // max work envelope for soft limits @@ -398,7 +398,7 @@ typedef struct cmAxis { } AxisConfig_t; -typedef struct cmSingleton { // struct to manage cm globals and cycles +typedef struct { // struct to manage mach globals and cycles // coordinate systems and offsets absolute (G53) + G54,G55,G56,G57,G58,G59 float offset[COORDS + 1][AXES]; float origin_offset[AXES]; // G92 offsets @@ -411,15 +411,15 @@ typedef struct cmSingleton { // struct to manage cm globals and cycles // settings for axes X,Y,Z,A B,C AxisConfig_t a[AXES]; - cmCombinedState_t combined_state; // combination of states for display - cmMachineState_t machine_state; - cmCycleState_t cycle_state; - cmMotionState_t motion_state; - cmFeedholdState_t hold_state; // hold: feedhold sub-state machine - cmHomingState_t homing_state; // home: homing cycle sub-state machine + machCombinedState_t combined_state; // combination of states for display + machMachineState_t machine_state; + machCycleState_t cycle_state; + machMotionState_t motion_state; + machFeedholdState_t hold_state; // hold: feedhold sub-state machine + machHomingState_t homing_state; // home: homing cycle sub-state machine bool homed[AXES]; // individual axis homing flags - cmProbeState_t probe_state; + machProbeState_t probe_state; float probe_results[AXES]; // probing results bool feedhold_requested; // feedhold character received @@ -431,138 +431,138 @@ typedef struct cmSingleton { // struct to manage cm globals and cycles GCodeState_t gm; // core gcode model state GCodeState_t gn; // gcode input values GCodeState_t gf; // gcode input flags -} cmSingleton_t; +} machSingleton_t; -extern cmSingleton_t cm; // machine controller singleton +extern machSingleton_t mach; // machine controller singleton // Model state getters and setters -uint32_t cm_get_line(); -cmCombinedState_t cm_get_combined_state(); -cmMachineState_t cm_get_machine_state(); -cmCycleState_t cm_get_cycle_state(); -cmMotionState_t cm_get_motion_state(); -cmFeedholdState_t cm_get_hold_state(); -cmHomingState_t cm_get_homing_state(); -cmMotionMode_t cm_get_motion_mode(); -cmCoordSystem_t cm_get_coord_system(); -cmUnitsMode_t cm_get_units_mode(); -cmPlane_t cm_get_select_plane(); -cmPathControlMode_t cm_get_path_control(); -cmDistanceMode_t cm_get_distance_mode(); -cmFeedRateMode_t cm_get_feed_rate_mode(); -uint8_t cm_get_tool(); -cmSpindleMode_t cm_get_spindle_mode(); -bool cm_get_runtime_busy(); -float cm_get_feed_rate(); - -void cm_set_machine_state(cmMachineState_t machine_state); -void cm_set_motion_state(cmMotionState_t motion_state); -void cm_set_motion_mode(cmMotionMode_t motion_mode); -void cm_set_spindle_mode(cmSpindleMode_t spindle_mode); -void cm_set_spindle_speed_parameter(float speed); -void cm_set_tool_number(uint8_t tool); -void cm_set_absolute_override(bool absolute_override); -void cm_set_model_line(uint32_t line); - -float cm_get_axis_jerk(uint8_t axis); -void cm_set_axis_jerk(uint8_t axis, float jerk); +uint32_t mach_get_line(); +machCombinedState_t mach_get_combined_state(); +machMachineState_t mach_get_machine_state(); +machCycleState_t mach_get_cycle_state(); +machMotionState_t mach_get_motion_state(); +machFeedholdState_t mach_get_hold_state(); +machHomingState_t mach_get_homing_state(); +machMotionMode_t mach_get_motion_mode(); +machCoordSystem_t mach_get_coord_system(); +machUnitsMode_t mach_get_units_mode(); +machPlane_t mach_get_select_plane(); +machPathControlMode_t mach_get_path_control(); +machDistanceMode_t mach_get_distance_mode(); +machFeedRateMode_t mach_get_feed_rate_mode(); +uint8_t mach_get_tool(); +machSpindleMode_t mach_get_spindle_mode(); +bool mach_get_runtime_busy(); +float mach_get_feed_rate(); + +void mach_set_machine_state(machMachineState_t machine_state); +void mach_set_motion_state(machMotionState_t motion_state); +void mach_set_motion_mode(machMotionMode_t motion_mode); +void mach_set_spindle_mode(machSpindleMode_t spindle_mode); +void mach_set_spindle_speed_parameter(float speed); +void mach_set_tool_number(uint8_t tool); +void mach_set_absolute_override(bool absolute_override); +void mach_set_model_line(uint32_t line); + +float mach_get_axis_jerk(uint8_t axis); +void mach_set_axis_jerk(uint8_t axis, float jerk); // Coordinate systems and offsets -float cm_get_active_coord_offset(uint8_t axis); -float cm_get_work_offset(uint8_t axis); -void cm_set_work_offsets(); -float cm_get_absolute_position(uint8_t axis); -float cm_get_work_position(uint8_t axis); +float mach_get_active_coord_offset(uint8_t axis); +float mach_get_work_offset(uint8_t axis); +void mach_set_work_offsets(); +float mach_get_absolute_position(uint8_t axis); +float mach_get_work_position(uint8_t axis); // Critical helpers -void cm_calc_move_time(const float axis_length[], const float axis_square[]); -void cm_update_model_position_from_runtime(); -void cm_finalize_move(); -stat_t cm_deferred_write_callback(); -void cm_set_model_target(float target[], float flag[]); -stat_t cm_test_soft_limits(float target[]); +void mach_calc_move_time(const float axis_length[], const float axis_square[]); +void mach_update_model_position_from_runtime(); +void mach_finalize_move(); +stat_t mach_deferred_write_callback(); +void mach_set_model_target(float target[], float flag[]); +stat_t mach_test_soft_limits(float target[]); // machining functions defined by NIST [organized by NIST Gcode doc] // Initialization and termination (4.3.2) void machine_init(); /// enter alarm state. returns same status code -stat_t cm_alarm(const char *location, stat_t status); -stat_t cm_clear(); +stat_t mach_alarm(const char *location, stat_t status); +stat_t mach_clear(); -#define CM_ALARM(CODE) cm_alarm(STATUS_LOCATION, CODE) +#define CM_ALARM(CODE) mach_alarm(STATUS_LOCATION, CODE) // Representation (4.3.3) -void cm_set_plane(cmPlane_t plane); -void cm_set_units_mode(cmUnitsMode_t mode); -void cm_set_distance_mode(cmDistanceMode_t mode); -void cm_set_coord_offsets(cmCoordSystem_t coord_system, float offset[], +void mach_set_plane(machPlane_t plane); +void mach_set_units_mode(machUnitsMode_t mode); +void mach_set_distance_mode(machDistanceMode_t mode); +void mach_set_coord_offsets(machCoordSystem_t coord_system, float offset[], float flag[]); -void cm_set_position(int axis, float position); -void cm_set_absolute_origin(float origin[], float flag[]); +void mach_set_position(int axis, float position); +void mach_set_absolute_origin(float origin[], float flag[]); -void cm_set_coord_system(cmCoordSystem_t coord_system); -void cm_set_origin_offsets(float offset[], float flag[]); -void cm_reset_origin_offsets(); -void cm_suspend_origin_offsets(); -void cm_resume_origin_offsets(); +void mach_set_coord_system(machCoordSystem_t coord_system); +void mach_set_origin_offsets(float offset[], float flag[]); +void mach_reset_origin_offsets(); +void mach_suspend_origin_offsets(); +void mach_resume_origin_offsets(); // Free Space Motion (4.3.4) -stat_t cm_straight_traverse(float target[], float flags[]); -void cm_set_g28_position(); -stat_t cm_goto_g28_position(float target[], float flags[]); -void cm_set_g30_position(); -stat_t cm_goto_g30_position(float target[], float flags[]); +stat_t mach_straight_traverse(float target[], float flags[]); +void mach_set_g28_position(); +stat_t mach_goto_g28_position(float target[], float flags[]); +void mach_set_g30_position(); +stat_t mach_goto_g30_position(float target[], float flags[]); // Machining Attributes (4.3.5) -void cm_set_feed_rate(float feed_rate); -void cm_set_feed_rate_mode(cmFeedRateMode_t mode); -void cm_set_path_control(cmPathControlMode_t mode); +void mach_set_feed_rate(float feed_rate); +void mach_set_feed_rate_mode(machFeedRateMode_t mode); +void mach_set_path_control(machPathControlMode_t mode); // Machining Functions (4.3.6) -stat_t cm_straight_feed(float target[], float flags[]); -stat_t cm_arc_feed(float target[], float flags[], +stat_t mach_straight_feed(float target[], float flags[]); +stat_t mach_arc_feed(float target[], float flags[], float i, float j, float k, float radius, uint8_t motion_mode); -stat_t cm_dwell(float seconds); +stat_t mach_dwell(float seconds); // Spindle Functions (4.3.7) see spindle.h // Tool Functions (4.3.8) -void cm_select_tool(uint8_t tool); -void cm_change_tool(uint8_t tool); +void mach_select_tool(uint8_t tool); +void mach_change_tool(uint8_t tool); // Miscellaneous Functions (4.3.9) -void cm_mist_coolant_control(bool mist_coolant); -void cm_flood_coolant_control(bool flood_coolant); +void mach_mist_coolant_control(bool mist_coolant); +void mach_flood_coolant_control(bool flood_coolant); -void cm_override_enables(bool flag); -void cm_feed_rate_override_enable(bool flag); -void cm_feed_rate_override_factor(bool flag); -void cm_traverse_override_enable(bool flag); -void cm_traverse_override_factor(bool flag); -void cm_spindle_override_enable(bool flag); -void cm_spindle_override_factor(bool flag); +void mach_override_enables(bool flag); +void mach_feed_rate_override_enable(bool flag); +void mach_feed_rate_override_factor(bool flag); +void mach_traverse_override_enable(bool flag); +void mach_traverse_override_factor(bool flag); +void mach_spindle_override_enable(bool flag); +void mach_spindle_override_factor(bool flag); -void cm_message(const char *message); +void mach_message(const char *message); // Program Functions (4.3.10) -void cm_request_feedhold(); -void cm_request_queue_flush(); -void cm_request_cycle_start(); +void mach_request_feedhold(); +void mach_request_queue_flush(); +void mach_request_cycle_start(); -void cm_feedhold_callback(); -stat_t cm_queue_flush(); +void mach_feedhold_callback(); +stat_t mach_queue_flush(); -void cm_cycle_start(); -void cm_cycle_end(); -void cm_feedhold(); -void cm_program_stop(); -void cm_optional_program_stop(); -void cm_program_end(); +void mach_cycle_start(); +void mach_cycle_end(); +void mach_feedhold(); +void mach_program_stop(); +void mach_optional_program_stop(); +void mach_program_end(); // Cycles -char cm_get_axis_char(int8_t axis); +char mach_get_axis_char(int8_t axis); diff --git a/src/main.c b/src/main.c index 936c1f3..d759cbb 100644 --- a/src/main.c +++ b/src/main.c @@ -78,10 +78,10 @@ int main() { // main loop while (true) { hw_reset_handler(); // handle hard reset requests - cm_feedhold_callback(); // feedhold state machine - cm_arc_callback(); // arc generation runs - cm_homing_callback(); // G28.2 continuation - cm_probe_callback(); // G38.2 continuation + mach_feedhold_callback(); // feedhold state machine + mach_arc_callback(); // arc generation runs + mach_homing_callback(); // G28.2 continuation + mach_probe_callback(); // G38.2 continuation command_callback(); // process next command report_callback(); // report changes wdt_reset(); diff --git a/src/motor.c b/src/motor.c index f19eccc..ecaa703 100644 --- a/src/motor.c +++ b/src/motor.c @@ -58,8 +58,8 @@ typedef struct { // Config uint8_t motor_map; // map motor to axis uint16_t microsteps; // microsteps per full step - cmMotorPolarity_t polarity; - cmMotorPowerMode_t power_mode; + machMotorPolarity_t polarity; + machMotorPowerMode_t power_mode; float step_angle; // degrees per whole step float travel_rev; // mm or deg of travel per motor revolution uint8_t step_pin; @@ -72,7 +72,7 @@ typedef struct { // Runtime state motorPowerState_t power_state; // state machine for managing motor power uint32_t timeout; - cmMotorFlags_t flags; + machMotorFlags_t flags; int32_t encoder; uint16_t steps; uint8_t last_clock; @@ -81,7 +81,7 @@ typedef struct { uint8_t timer_clock; // clock divisor setting or zero for off uint16_t timer_period; // clock period counter bool positive; // step sign - cmDirection_t direction; // travel direction corrected for polarity + machDirection_t direction; // travel direction corrected for polarity // Step error correction int32_t correction_holdoff; // count down segments between corrections @@ -310,7 +310,7 @@ stat_t motor_rtc_callback() { // called by controller void print_status_flags(uint8_t flags); -void motor_error_callback(int motor, cmMotorFlags_t errors) { +void motor_error_callback(int motor, machMotorFlags_t errors) { if (motors[motor].power_state != MOTOR_ACTIVE) return; motors[motor].flags |= errors; diff --git a/src/motor.h b/src/motor.h index abce100..ba678e7 100644 --- a/src/motor.h +++ b/src/motor.h @@ -44,7 +44,7 @@ typedef enum { MOTOR_FLAG_OVERTEMP_WARN_bm | MOTOR_FLAG_OVERTEMP_bm | MOTOR_FLAG_SHORTED_bm) -} cmMotorFlags_t; +} machMotorFlags_t; typedef enum { @@ -54,13 +54,13 @@ typedef enum { // de-powered out of cycle MOTOR_POWERED_ONLY_WHEN_MOVING, // idles shortly after stopped, even in cycle MOTOR_POWER_MODE_MAX_VALUE // for input range checking -} cmMotorPowerMode_t; +} machMotorPowerMode_t; typedef enum { MOTOR_POLARITY_NORMAL, MOTOR_POLARITY_REVERSED -} cmMotorPolarity_t; +} machMotorPolarity_t; void motor_init(); @@ -78,7 +78,7 @@ bool motor_energizing(); void motor_driver_callback(int motor); stat_t motor_rtc_callback(); -void motor_error_callback(int motor, cmMotorFlags_t errors); +void motor_error_callback(int motor, machMotorFlags_t errors); void motor_load_move(int motor); void motor_end_move(int motor); diff --git a/src/plan/arc.c b/src/plan/arc.c index fec5842..de44ee3 100644 --- a/src/plan/arc.c +++ b/src/plan/arc.c @@ -91,25 +91,25 @@ arc_t arc = {}; */ static void _estimate_arc_time() { // Determine move time at requested feed rate - if (cm.gm.feed_rate_mode == INVERSE_TIME_MODE) { + if (mach.gm.feed_rate_mode == INVERSE_TIME_MODE) { // inverse feed rate has been normalized to minutes - arc.arc_time = cm.gm.feed_rate; + arc.arc_time = mach.gm.feed_rate; // reset feed rate so next block requires an explicit feed rate setting - cm.gm.feed_rate = 0; - cm.gm.feed_rate_mode = UNITS_PER_MINUTE_MODE; + mach.gm.feed_rate = 0; + mach.gm.feed_rate_mode = UNITS_PER_MINUTE_MODE; - } else arc.arc_time = arc.length / cm.gm.feed_rate; + } else arc.arc_time = arc.length / mach.gm.feed_rate; // Downgrade the time if there is a rate-limiting axis arc.arc_time = - max(arc.arc_time, arc.planar_travel/cm.a[arc.plane_axis_0].feedrate_max); + max(arc.arc_time, arc.planar_travel/mach.a[arc.plane_axis_0].feedrate_max); arc.arc_time = - max(arc.arc_time, arc.planar_travel/cm.a[arc.plane_axis_1].feedrate_max); + max(arc.arc_time, arc.planar_travel/mach.a[arc.plane_axis_1].feedrate_max); if (0 < fabs(arc.linear_travel)) arc.arc_time = max(arc.arc_time, - fabs(arc.linear_travel/cm.a[arc.linear_axis].feedrate_max)); + fabs(arc.linear_travel/mach.a[arc.linear_axis].feedrate_max)); } @@ -192,8 +192,8 @@ static void _estimate_arc_time() { */ static stat_t _compute_arc_offsets_from_radius() { // Calculate the change in position along each selected axis - float x = cm.ms.target[arc.plane_axis_0] - cm.position[arc.plane_axis_0]; - float y = cm.ms.target[arc.plane_axis_1] - cm.position[arc.plane_axis_1]; + float x = mach.ms.target[arc.plane_axis_0] - mach.position[arc.plane_axis_0]; + float y = mach.ms.target[arc.plane_axis_1] - mach.position[arc.plane_axis_1]; // *** From Forrest Green - Other Machine Co, 3/27/14 // If the distance between endpoints is greater than the arc diameter, disc @@ -212,7 +212,7 @@ static stat_t _compute_arc_offsets_from_radius() { // Invert the sign of h_x2_div_d if circle is counter clockwise (see header // notes) - if (cm.gm.motion_mode == MOTION_MODE_CCW_ARC) h_x2_div_d = -h_x2_div_d; + if (mach.gm.motion_mode == MOTION_MODE_CCW_ARC) h_x2_div_d = -h_x2_div_d; // Negative R is g-code-alese for "I want a circle with more than 180 degrees // of travel" (go figure!), even though it is advised against ever generating @@ -282,7 +282,7 @@ static stat_t _compute_arc() { // g18_correction is used to invert G18 XZ plane arcs for proper CW // orientation - float g18_correction = (cm.gm.select_plane == PLANE_XZ) ? -1 : 1; + float g18_correction = (mach.gm.select_plane == PLANE_XZ) ? -1 : 1; if (arc.full_circle) { // angular travel always starts as zero for full circles @@ -307,13 +307,13 @@ static stat_t _compute_arc() { arc.angular_travel = arc.theta_end - arc.theta; // reverse travel direction if it's CCW arc - if (cm.gm.motion_mode == MOTION_MODE_CCW_ARC) + if (mach.gm.motion_mode == MOTION_MODE_CCW_ARC) arc.angular_travel -= 2 * M_PI * g18_correction; } } // Add in travel for rotations - if (cm.gm.motion_mode == MOTION_MODE_CW_ARC) + if (mach.gm.motion_mode == MOTION_MODE_CW_ARC) arc.angular_travel += (2*M_PI * arc.rotations * g18_correction); else arc.angular_travel -= (2*M_PI * arc.rotations * g18_correction); @@ -361,20 +361,20 @@ static stat_t _compute_arc() { * Generates an arc by queuing line segments to the move buffer. The arc is * approximated by generating a large number of tiny, linear arc_segments. */ -stat_t cm_arc_feed(float target[], float flags[], // arc endpoints +stat_t mach_arc_feed(float target[], float flags[], // arc endpoints float i, float j, float k, // raw arc offsets float radius, // non-zero radius implies radius mode uint8_t motion_mode) { // defined motion mode // Set axis plane and trap arc specification errors // trap missing feed rate - if (cm.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(cm.gm.feed_rate)) + if (mach.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(mach.gm.feed_rate)) return STAT_GCODE_FEEDRATE_NOT_SPECIFIED; // set radius mode flag and do simple test(s) - bool radius_f = fp_NOT_ZERO(cm.gf.arc_radius); // set true if radius arc + bool radius_f = fp_NOT_ZERO(mach.gf.arc_radius); // set true if radius arc // radius value must be + and > minimum radius - if (radius_f && cm.gn.arc_radius < MIN_ARC_RADIUS) + if (radius_f && mach.gn.arc_radius < MIN_ARC_RADIUS) return STAT_ARC_RADIUS_OUT_OF_TOLERANCE; // setup some flags @@ -382,15 +382,15 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints bool target_y = fp_NOT_ZERO(flags[AXIS_Y]); bool target_z = fp_NOT_ZERO(flags[AXIS_Z]); - bool offset_i = fp_NOT_ZERO(cm.gf.arc_offset[0]); // is offset I specified - bool offset_j = fp_NOT_ZERO(cm.gf.arc_offset[1]); // J - bool offset_k = fp_NOT_ZERO(cm.gf.arc_offset[2]); // K + bool offset_i = fp_NOT_ZERO(mach.gf.arc_offset[0]); // is offset I specified + bool offset_j = fp_NOT_ZERO(mach.gf.arc_offset[1]); // J + bool offset_k = fp_NOT_ZERO(mach.gf.arc_offset[2]); // K // 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. // G17 - the vast majority of arcs are in the G17 (XY) plane - if (cm.gm.select_plane == PLANE_XY) { + if (mach.gm.select_plane == PLANE_XY) { arc.plane_axis_0 = AXIS_X; arc.plane_axis_1 = AXIS_Y; arc.linear_axis = AXIS_Z; @@ -405,7 +405,7 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints // but error if k is present return STAT_ARC_SPECIFICATION_ERROR; - } else if (cm.gm.select_plane == PLANE_XZ) { // G18 + } else if (mach.gm.select_plane == PLANE_XZ) { // G18 arc.plane_axis_0 = AXIS_X; arc.plane_axis_1 = AXIS_Z; arc.linear_axis = AXIS_Y; @@ -415,7 +415,7 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints return STAT_ARC_AXIS_MISSING_FOR_SELECTED_PLANE; } else if (offset_j) return STAT_ARC_SPECIFICATION_ERROR; - } else if (cm.gm.select_plane == PLANE_YZ) { // G19 + } else if (mach.gm.select_plane == PLANE_YZ) { // G19 arc.plane_axis_0 = AXIS_Y; arc.plane_axis_1 = AXIS_Z; arc.linear_axis = AXIS_X; @@ -428,21 +428,21 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints // set values in the Gcode model state & copy it (line was already // captured) - cm_set_model_target(target, flags); + mach_set_model_target(target, flags); // in radius mode it's an error for start == end - if (radius_f && fp_EQ(cm.position[AXIS_X], cm.ms.target[AXIS_X]) && - fp_EQ(cm.position[AXIS_Y], cm.ms.target[AXIS_Y]) && - fp_EQ(cm.position[AXIS_Z], cm.ms.target[AXIS_Z])) + if (radius_f && fp_EQ(mach.position[AXIS_X], mach.ms.target[AXIS_X]) && + fp_EQ(mach.position[AXIS_Y], mach.ms.target[AXIS_Y]) && + fp_EQ(mach.position[AXIS_Z], mach.ms.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); // resolved offsets to gm - cm.ms.line = cm.gm.line; // copy line number - memcpy(&arc.ms, &cm.ms, sizeof(MoveState_t)); // context to arc singleton + mach.gm.motion_mode = motion_mode; + mach_set_work_offsets(&mach.gm); // resolved offsets to gm + mach.ms.line = mach.gm.line; // copy line number + memcpy(&arc.ms, &mach.ms, sizeof(MoveState_t)); // context to arc singleton - copy_vector(arc.position, cm.position); // arc pos from gcode model + copy_vector(arc.position, mach.position); // arc pos from gcode model arc.radius = TO_MILLIMETERS(radius); // set arc radius or zero @@ -450,7 +450,7 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints arc.offset[1] = TO_MILLIMETERS(j); arc.offset[2] = TO_MILLIMETERS(k); - arc.rotations = floor(fabs(cm.gn.parameter)); // P must be positive integer + arc.rotations = floor(fabs(mach.gn.parameter)); // P must be positive integer // determine if this is a full circle arc. Evaluates true if no target is set arc.full_circle = @@ -462,9 +462,9 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints // trap zero length arcs that _compute_arc can throw if (fp_ZERO(arc.length)) return STAT_MINIMUM_LENGTH_MOVE; - cm_cycle_start(); // if not already started + mach_cycle_start(); // if not already started arc.run_state = MOVE_RUN; // enable arc run from the callback - cm_finalize_move(); + mach_finalize_move(); return STAT_OK; } @@ -477,7 +477,7 @@ stat_t cm_arc_feed(float target[], float flags[], // arc endpoints * * Parts of this routine were originally sourced from the grbl project. */ -void cm_arc_callback() { +void mach_arc_callback() { while (arc.run_state != MOVE_OFF && mp_get_planner_buffer_room()) { arc.theta += arc.arc_segment_theta; arc.ms.target[arc.plane_axis_0] = @@ -494,11 +494,11 @@ void cm_arc_callback() { } -bool cm_arc_active() {return arc.run_state != MOVE_OFF;} +bool mach_arc_active() {return arc.run_state != MOVE_OFF;} /// Stop arc movement without maintaining position /// OK to call if no arc is running -void cm_abort_arc() { +void mach_abort_arc() { arc.run_state = MOVE_OFF; } diff --git a/src/plan/arc.h b/src/plan/arc.h index e1a8ff0..c7a69ce 100644 --- a/src/plan/arc.h +++ b/src/plan/arc.h @@ -38,6 +38,6 @@ #define MIN_ARC_SEGMENT_TIME (MIN_ARC_SEGMENT_USEC / MICROSECONDS_PER_MINUTE) -void cm_arc_callback(); -bool cm_arc_active(); -void cm_abort_arc(); +void mach_arc_callback(); +bool mach_arc_active(); +void mach_abort_arc(); diff --git a/src/plan/buffer.h b/src/plan/buffer.h index c05ab25..8ce9cb3 100644 --- a/src/plan/buffer.h +++ b/src/plan/buffer.h @@ -64,7 +64,7 @@ typedef enum { // bf->buffer_state values // Callbacks -typedef void (*cm_exec_t)(float[], float[]); +typedef void (*mach_exec_t)(float[], float[]); struct mpBuffer; typedef stat_t (*bf_func_t)(struct mpBuffer *bf); @@ -74,7 +74,7 @@ typedef struct mpBuffer { // See Planning Velocity Notes struct mpBuffer *nx; // pointer to next buffer bf_func_t bf_func; // callback to buffer exec function - cm_exec_t cm_func; // callback to machine + mach_exec_t mach_func; // callback to machine float naive_move_time; diff --git a/src/plan/command.c b/src/plan/command.c index 545bd5f..2209f9a 100644 --- a/src/plan/command.c +++ b/src/plan/command.c @@ -28,8 +28,9 @@ \******************************************************************************/ /* How this works: - * - A command is called by the Gcode interpreter (cm_, e.g. M code) - * - cm_ function calls mp_queue_command which puts it in the planning queue + * - A command is called by the Gcode interpreter (mach_, + * e.g. M code) + * - mach_ function calls mp_queue_command which puts it in the planning queue * (bf buffer) which sets some parameters and registers a callback to the * execution function in the machine. * - When the planning queue gets to the function it calls _exec_command() @@ -59,7 +60,7 @@ static stat_t _exec_command(mpBuf_t *bf) { /// Queue a synchronous Mcode, program control, or other command -void mp_queue_command(cm_exec_t cm_exec, float *value, float *flag) { +void mp_queue_command(mach_exec_t mach_exec, float *value, float *flag) { mpBuf_t *bf = mp_get_write_buffer(); if (!bf) { @@ -69,7 +70,7 @@ void mp_queue_command(cm_exec_t cm_exec, float *value, float *flag) { bf->move_type = MOVE_TYPE_COMMAND; bf->bf_func = _exec_command; // callback to planner queue exec function - bf->cm_func = cm_exec; // callback to machine exec function + bf->mach_func = mach_exec; // callback to machine exec function // Store values and flags in planner buffer for (int axis = 0; axis < AXES; axis++) { @@ -78,14 +79,14 @@ void mp_queue_command(cm_exec_t cm_exec, float *value, float *flag) { } // Must be final operation before exit - mp_commit_write_buffer(cm_get_line(), MOVE_TYPE_COMMAND); + mp_commit_write_buffer(mach_get_line(), MOVE_TYPE_COMMAND); } void mp_runtime_command(mpBuf_t *bf) { // Use values & flags stored in mp_queue_command() - bf->cm_func(bf->ms.target, bf->unit); + bf->mach_func(bf->ms.target, bf->unit); // Free buffer & perform cycle_end if planner is empty - if (mp_free_run_buffer()) cm_cycle_end(); + if (mp_free_run_buffer()) mach_cycle_end(); } diff --git a/src/plan/command.h b/src/plan/command.h index 1db6f81..599bf11 100644 --- a/src/plan/command.h +++ b/src/plan/command.h @@ -29,5 +29,5 @@ #include "plan/buffer.h" -void mp_queue_command(cm_exec_t cm_exec, float *value, float *flag); +void mp_queue_command(mach_exec_t mach_exec, float *value, float *flag); void mp_runtime_command(mpBuf_t *bf); diff --git a/src/plan/dwell.c b/src/plan/dwell.c index 7e2305a..f88926a 100644 --- a/src/plan/dwell.c +++ b/src/plan/dwell.c @@ -42,7 +42,7 @@ static stat_t _exec_dwell(mpBuf_t *bf) { st_prep_dwell(bf->ms.move_time); // in seconds // free buffer & perform cycle_end if planner is empty - if (mp_free_run_buffer()) cm_cycle_end(); + if (mp_free_run_buffer()) mach_cycle_end(); return STAT_OK; } @@ -60,7 +60,7 @@ stat_t mp_dwell(float seconds) { bf->move_state = MOVE_NEW; // must be final operation before exit - mp_commit_write_buffer(cm_get_line(), MOVE_TYPE_DWELL); + mp_commit_write_buffer(mach_get_line(), MOVE_TYPE_DWELL); return STAT_OK; } diff --git a/src/plan/exec.c b/src/plan/exec.c index caa506b..69744d0 100644 --- a/src/plan/exec.c +++ b/src/plan/exec.c @@ -70,7 +70,7 @@ static stat_t _exec_aline_segment() { // compute target from segment time and velocity Don't do waypoint // correction if you are going into a hold. if (--mr.segment_count == 0 && mr.section_state == SECTION_2nd_HALF && - cm.motion_state == MOTION_RUN && cm.cycle_state == CYCLE_MACHINING) + mach.motion_state == MOTION_RUN && mach.cycle_state == CYCLE_MACHINING) copy_vector(mr.ms.target, mr.waypoint[mr.section]); else { @@ -701,7 +701,7 @@ stat_t mp_exec_aline(mpBuf_t *bf) { // start a new move by setting up local context (singleton) if (mr.move_state == MOVE_OFF) { - if (cm.hold_state == FEEDHOLD_HOLD) + if (mach.hold_state == FEEDHOLD_HOLD) return STAT_NOOP; // stops here if holding // initialization to process the new incoming bf buffer (Gcode block) @@ -717,7 +717,7 @@ stat_t mp_exec_aline(mpBuf_t *bf) { // prevent overplanning (Note 2) bf->nx->replannable = false; // free buffer & end cycle if planner is empty - if (mp_free_run_buffer()) cm_cycle_end(); + if (mp_free_run_buffer()) mach_cycle_end(); return STAT_NOOP; } @@ -767,12 +767,12 @@ stat_t mp_exec_aline(mpBuf_t *bf) { // Feedhold processing. Refer to machine.h for state machine // Catch the feedhold request and start the planning the hold - if (cm.hold_state == FEEDHOLD_SYNC) cm.hold_state = FEEDHOLD_PLAN; + if (mach.hold_state == FEEDHOLD_SYNC) mach.hold_state = FEEDHOLD_PLAN; // Look for the end of the decel to go into HOLD state - if (cm.hold_state == FEEDHOLD_DECEL && status == STAT_OK) { - cm.hold_state = FEEDHOLD_HOLD; - cm_set_motion_state(MOTION_HOLD); + if (mach.hold_state == FEEDHOLD_DECEL && status == STAT_OK) { + mach.hold_state = FEEDHOLD_HOLD; + mach_set_motion_state(MOTION_HOLD); report_request(); } @@ -790,7 +790,7 @@ stat_t mp_exec_aline(mpBuf_t *bf) { bf->nx->replannable = false; // prevent overplanning (Note 2) if (bf->move_state == MOVE_RUN && mp_free_run_buffer()) - cm_cycle_end(); // free buffer & end cycle if planner is empty + mach_cycle_end(); // free buffer & end cycle if planner is empty } return status; @@ -806,8 +806,8 @@ stat_t mp_exec_move() { // Manage cycle and motion state transitions // Cycle auto-start for lines only - if (bf->move_type == MOVE_TYPE_ALINE && cm.motion_state == MOTION_STOP) - cm_set_motion_state(MOTION_RUN); + if (bf->move_type == MOVE_TYPE_ALINE && mach.motion_state == MOTION_STOP) + mach_set_motion_state(MOTION_RUN); if (!bf->bf_func) return CM_ALARM(STAT_INTERNAL_ERROR); // never supposed to get here diff --git a/src/plan/feedhold.c b/src/plan/feedhold.c index b38a071..b2db1aa 100644 --- a/src/plan/feedhold.c +++ b/src/plan/feedhold.c @@ -38,13 +38,13 @@ #include #include -/* Feedhold is executed as cm.hold_state transitions executed inside +/* Feedhold is executed as mach.hold_state transitions executed inside * _exec_aline() and main loop callbacks to these functions: * mp_plan_hold_callback() and mp_end_hold(). * * Holds work like this: * - * - Hold is asserted by calling cm_feedhold() (usually invoked via a + * - Hold is asserted by calling mach_feedhold() (usually invoked via a * ! char) If hold_state is OFF and motion_state is RUNning it sets * hold_state to SYNC and motion_state to HOLD. * @@ -67,7 +67,7 @@ * TRUE. It can occur any time after the hold is requested - either * before or after motion stops. * - * - mp_end_hold() is executed from cm_feedhold_sequencing_callback() + * - mp_end_hold() is executed from mach_feedhold_sequencing_callback() * once the hold state == HOLD and a cycle_start has been * requested.This sets the hold state to OFF which enables * _exec_aline() to continue processing. Move execution begins with @@ -121,7 +121,7 @@ static float _compute_next_segment_velocity() { /// replan block list to execute hold void mp_plan_hold_callback() { - if (cm.hold_state != FEEDHOLD_PLAN) return; // not planning a feedhold + if (mach.hold_state != FEEDHOLD_PLAN) return; // not planning a feedhold mpBuf_t *bp = mp_get_run_buffer(); // working buffer pointer if (!bp) return; // Oops! nothing's running @@ -166,7 +166,7 @@ void mp_plan_hold_callback() { _reset_replannable_list(); // make it replan all the blocks mp_plan_block_list(mp_get_last_buffer(), &mr_flag); - cm.hold_state = FEEDHOLD_DECEL; // set state to decelerate and exit + mach.hold_state = FEEDHOLD_DECEL; // set state to decelerate and exit return; } @@ -220,17 +220,17 @@ void mp_plan_hold_callback() { _reset_replannable_list(); // replan all the blocks mp_plan_block_list(mp_get_last_buffer(), &mr_flag); - cm.hold_state = FEEDHOLD_DECEL; // set state to decelerate and exit + mach.hold_state = FEEDHOLD_DECEL; // set state to decelerate and exit } /// End a feedhold, release the hold and restart block list void mp_end_hold() { - if (cm.hold_state == FEEDHOLD_END_HOLD) { - cm.hold_state = FEEDHOLD_OFF; + if (mach.hold_state == FEEDHOLD_END_HOLD) { + mach.hold_state = FEEDHOLD_OFF; // 0 means nothing's running - if (!mp_get_run_buffer()) cm_set_motion_state(MOTION_STOP); - else cm.motion_state = MOTION_RUN; + if (!mp_get_run_buffer()) mach_set_motion_state(MOTION_STOP); + else mach.motion_state = MOTION_RUN; } } diff --git a/src/plan/jog.c b/src/plan/jog.c index 1ca6908..265402f 100644 --- a/src/plan/jog.c +++ b/src/plan/jog.c @@ -71,7 +71,7 @@ static stat_t _exec_jog(mpBuf_t *bf) { // Compute new velocities and travel for (int axis = 0; axis < AXES; axis++) { - float targetV = jr.target_velocity[axis] * cm.a[axis].velocity_max; + float targetV = jr.target_velocity[axis] * mach.a[axis].velocity_max; float deltaV = targetV - jr.current_velocity[axis]; float sign = deltaV < 0 ? -1 : 1; @@ -90,7 +90,7 @@ static stat_t _exec_jog(mpBuf_t *bf) { for (int motor = 0; motor < MOTORS; motor++) { int axis = motor_get_axis(motor); float steps = motor_get_encoder(axis); - cm_set_position(axis, steps / motor_get_steps_per_unit(motor)); + mach_set_position(axis, steps / motor_get_steps_per_unit(motor)); } // Release buffer diff --git a/src/plan/line.c b/src/plan/line.c index 266599a..d0de8f9 100644 --- a/src/plan/line.c +++ b/src/plan/line.c @@ -141,19 +141,19 @@ static float _get_junction_vmax(const float a_unit[], const float b_unit[]) { if (costheta > 0.99) return 0; // reversal cases // Fuse the junction deviations into a vector sum - float a_delta = square(a_unit[AXIS_X] * cm.a[AXIS_X].junction_dev); - a_delta += square(a_unit[AXIS_Y] * cm.a[AXIS_Y].junction_dev); - a_delta += square(a_unit[AXIS_Z] * cm.a[AXIS_Z].junction_dev); - a_delta += square(a_unit[AXIS_A] * cm.a[AXIS_A].junction_dev); - a_delta += square(a_unit[AXIS_B] * cm.a[AXIS_B].junction_dev); - a_delta += square(a_unit[AXIS_C] * cm.a[AXIS_C].junction_dev); - - float b_delta = square(b_unit[AXIS_X] * cm.a[AXIS_X].junction_dev); - b_delta += square(b_unit[AXIS_Y] * cm.a[AXIS_Y].junction_dev); - b_delta += square(b_unit[AXIS_Z] * cm.a[AXIS_Z].junction_dev); - b_delta += square(b_unit[AXIS_A] * cm.a[AXIS_A].junction_dev); - b_delta += square(b_unit[AXIS_B] * cm.a[AXIS_B].junction_dev); - b_delta += square(b_unit[AXIS_C] * cm.a[AXIS_C].junction_dev); + float a_delta = square(a_unit[AXIS_X] * mach.a[AXIS_X].junction_dev); + a_delta += square(a_unit[AXIS_Y] * mach.a[AXIS_Y].junction_dev); + a_delta += square(a_unit[AXIS_Z] * mach.a[AXIS_Z].junction_dev); + a_delta += square(a_unit[AXIS_A] * mach.a[AXIS_A].junction_dev); + a_delta += square(a_unit[AXIS_B] * mach.a[AXIS_B].junction_dev); + a_delta += square(a_unit[AXIS_C] * mach.a[AXIS_C].junction_dev); + + float b_delta = square(b_unit[AXIS_X] * mach.a[AXIS_X].junction_dev); + b_delta += square(b_unit[AXIS_Y] * mach.a[AXIS_Y].junction_dev); + b_delta += square(b_unit[AXIS_Z] * mach.a[AXIS_Z].junction_dev); + b_delta += square(b_unit[AXIS_A] * mach.a[AXIS_A].junction_dev); + b_delta += square(b_unit[AXIS_B] * mach.a[AXIS_B].junction_dev); + b_delta += square(b_unit[AXIS_C] * mach.a[AXIS_C].junction_dev); float delta = (sqrt(a_delta) + sqrt(b_delta)) / 2; float sintheta_over2 = sqrt((1 - costheta) / 2); @@ -204,7 +204,7 @@ stat_t mp_aline(MoveState_t *ms) { return STAT_OK; } - // If cm_calc_move_time() says the move will take less than the + // If mach_calc_move_time() says the move will take less than the // minimum move time get a more accurate time estimate based on // starting velocity and acceleration. The time of the move is // determined by its initial velocity (Vi) and how much acceleration @@ -219,7 +219,7 @@ stat_t mp_aline(MoveState_t *ms) { // Vi <= previous block's entry_velocity + delta_velocity // Set move time in state - cm_calc_move_time(axis_length, axis_square); + mach_calc_move_time(axis_length, axis_square); if (ms->move_time < MIN_BLOCK_TIME) { // Max velocity change for this move @@ -324,7 +324,7 @@ stat_t mp_aline(MoveState_t *ms) { // compute unit vector term (zeros are already zero) bf->unit[axis] = axis_length[axis] / bf->length; // squaring axis_length ensures it's positive - C = axis_square[axis] * recip_L2 * cm.a[axis].recip_jerk; + C = axis_square[axis] * recip_L2 * mach.a[axis].recip_jerk; if (C > maxC) { maxC = C; @@ -333,7 +333,7 @@ stat_t mp_aline(MoveState_t *ms) { } // set up and pre-compute the jerk terms needed for this round of planning - bf->jerk = cm.a[bf->jerk_axis].jerk_max * JERK_MULTIPLIER / + bf->jerk = mach.a[bf->jerk_axis].jerk_max * JERK_MULTIPLIER / fabs(bf->unit[bf->jerk_axis]); // scale jerk // specialized comparison for tolerance of delta @@ -348,7 +348,7 @@ stat_t mp_aline(MoveState_t *ms) { // finish up the current block variables // exact stop cases already zeroed - if (cm_get_path_control() != PATH_EXACT_STOP) { + if (mach_get_path_control() != PATH_EXACT_STOP) { bf->replannable = true; exact_stop = 8675309; // an arbitrarily large floating point number } diff --git a/src/plan/planner.c b/src/plan/planner.c index eac0e81..1fcf7cb 100644 --- a/src/plan/planner.c +++ b/src/plan/planner.c @@ -45,7 +45,7 @@ * "planner" and "runtime" in function names. * * The Gcode model is owned by the machine and should - * only be accessed by cm_xxxx() functions. Data from the Gcode + * only be accessed by mach_xxxx() functions. Data from the Gcode * model is transferred to the planner by the mp_xxx() functions * called by the machine. * @@ -83,12 +83,12 @@ void planner_init() { * Does not affect the move currently running in mr. Does not affect * mm or gm model positions. This function is designed to be called * during a hold to reset the planner. This function should not - * generally be called; call cm_queue_flush() instead. + * generally be called; call mach_queue_flush() instead. */ void mp_flush_planner() { - cm_abort_arc(); + mach_abort_arc(); mp_init_buffers(); - cm_set_motion_state(MOTION_STOP); + mach_set_motion_state(MOTION_STOP); } @@ -195,7 +195,7 @@ void mp_kinematics(const float travel[], float steps[]) { // account. for (int motor = 0; motor < MOTORS; motor++) { int axis = motor_get_axis(motor); - if (cm.a[axis].axis_mode == AXIS_INHIBITED) steps[motor] = 0; + if (mach.a[axis].axis_mode == AXIS_INHIBITED) steps[motor] = 0; else steps[motor] = travel[axis] * motor_get_steps_per_unit(motor); } } diff --git a/src/probing.c b/src/probing.c index c48c12c..8f17512 100644 --- a/src/probing.c +++ b/src/probing.c @@ -61,7 +61,7 @@ struct pbProbingSingleton { // persistent probing runtime variables static struct pbProbingSingleton pb; -/* All cm_probe_cycle_start does is prevent any new commands from +/* All mach_probe_cycle_start does is prevent any new commands from * queueing to the planner so that the planner can move to a sop and * report MACHINE_PROGRAM_STOP. OK, it also queues the function * that's called once motion has stopped. @@ -74,7 +74,7 @@ static struct pbProbingSingleton pb; * before declaring the cycle to be done. Otherwise there is a nasty * race condition in the tg_controller() that will accept the next * command before the position of the final move has been recorded in - * the Gcode model. That's what the call to cm_get_runtime_busy() is + * the Gcode model. That's what the call to mach_get_runtime_busy() is * about. */ @@ -85,16 +85,16 @@ static void _probe_restore_settings() { // restore axis jerk for (int axis = 0; axis < AXES; axis++ ) - cm_set_axis_jerk(axis, pb.saved_jerk[axis]); + mach_set_axis_jerk(axis, pb.saved_jerk[axis]); // restore coordinate system and distance mode - cm_set_coord_system(pb.saved_coord_system); - cm_set_distance_mode(pb.saved_distance_mode); + mach_set_coord_system(pb.saved_coord_system); + mach_set_distance_mode(pb.saved_distance_mode); // update the model with actual position - cm_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); - cm_cycle_end(); - cm.cycle_state = CYCLE_OFF; + mach_set_motion_mode(MOTION_MODE_CANCEL_MOTION_MODE); + mach_cycle_end(); + mach.cycle_state = CYCLE_OFF; } @@ -106,14 +106,14 @@ static void _probing_error_exit(stat_t status) { static void _probing_finish() { bool closed = switch_is_active(SW_PROBE); - cm.probe_state = closed ? PROBE_SUCCEEDED : PROBE_FAILED; + mach.probe_state = closed ? PROBE_SUCCEEDED : PROBE_FAILED; for (int axis = 0; axis < AXES; axis++) { // if we got here because of a feed hold keep the model position correct - cm_set_position(axis, mp_get_runtime_work_position(axis)); + mach_set_position(axis, mp_get_runtime_work_position(axis)); // store the probe results - cm.probe_results[axis] = cm_get_absolute_position(axis); + mach.probe_results[axis] = mach_get_absolute_position(axis); } _probe_restore_settings(); @@ -125,7 +125,7 @@ static void _probing_start() { bool closed = switch_is_active(SW_PROBE); if (!closed) { - stat_t status = cm_straight_feed(pb.target, pb.flags); + stat_t status = mach_straight_feed(pb.target, pb.flags); if (status) return _probing_error_exit(status); } @@ -145,15 +145,16 @@ static void _probing_init() { // 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 = PROBE_FAILED; - cm.cycle_state = CYCLE_PROBE; + mach.probe_state = PROBE_FAILED; + mach.cycle_state = CYCLE_PROBE; // initialize the axes - save the jerk settings & switch to the jerk_homing // settings for (int 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_homing); // use homing jerk for probe - pb.start_position[axis] = cm_get_absolute_position(axis); + pb.saved_jerk[axis] = mach_get_axis_jerk(axis); // save the max jerk value + // use homing jerk for probe + mach_set_axis_jerk(axis, mach.a[axis].jerk_homing); + pb.start_position[axis] = mach_get_absolute_position(axis); } // error if the probe target is too close to the current position @@ -167,27 +168,27 @@ static void _probing_init() { _probing_error_exit(STAT_MOVE_DURING_PROBE); // probe in absolute machine coords - pb.saved_coord_system = cm_get_coord_system(&cm.gm); - pb.saved_distance_mode = cm_get_distance_mode(&cm.gm); - cm_set_distance_mode(ABSOLUTE_MODE); - cm_set_coord_system(ABSOLUTE_COORDS); + pb.saved_coord_system = mach_get_coord_system(&mach.gm); + pb.saved_distance_mode = mach_get_distance_mode(&mach.gm); + mach_set_distance_mode(ABSOLUTE_MODE); + mach_set_coord_system(ABSOLUTE_COORDS); - cm_spindle_control(SPINDLE_OFF); + mach_spindle_control(SPINDLE_OFF); // start the move pb.func = _probing_start; } -bool cm_is_probing() { - return cm.cycle_state == CYCLE_PROBE || cm.probe_state == PROBE_WAITING; +bool mach_is_probing() { + return mach.cycle_state == CYCLE_PROBE || mach.probe_state == PROBE_WAITING; } /// G38.2 homing cycle using limit switches -stat_t cm_straight_probe(float target[], float flags[]) { +stat_t mach_straight_probe(float target[], float flags[]) { // trap zero feed rate condition - if (cm.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(cm.gm.feed_rate)) + if (mach.gm.feed_rate_mode != INVERSE_TIME_MODE && fp_ZERO(mach.gm.feed_rate)) return STAT_GCODE_FEEDRATE_NOT_SPECIFIED; // trap no axes specified @@ -198,11 +199,11 @@ stat_t cm_straight_probe(float target[], float flags[]) { // set probe move endpoint copy_vector(pb.target, target); // set probe move endpoint copy_vector(pb.flags, flags); // set axes involved on the move - clear_vector(cm.probe_results); // clear the old probe position. + clear_vector(mach.probe_results); // clear the old probe position. // NOTE: relying on probe_results will not detect a probe to (0, 0, 0). // wait until planner queue empties before completing initialization - cm.probe_state = PROBE_WAITING; + mach.probe_state = PROBE_WAITING; pb.func = _probing_init; // bind probing initialization function return STAT_OK; @@ -210,9 +211,9 @@ stat_t cm_straight_probe(float target[], float flags[]) { /// main loop callback for running the homing cycle -void cm_probe_callback() { +void mach_probe_callback() { // sync to planner move ends - if (!cm_is_probing() || cm_get_runtime_busy()) return; + if (!mach_is_probing() || mach_get_runtime_busy()) return; pb.func(); // execute the current homing move } diff --git a/src/probing.h b/src/probing.h index d79e1d4..3c58203 100644 --- a/src/probing.h +++ b/src/probing.h @@ -32,6 +32,6 @@ #include -bool cm_is_probing(); -stat_t cm_straight_probe(float target[], float flags[]); -void cm_probe_callback(); +bool mach_is_probing(); +stat_t mach_straight_probe(float target[], float flags[]); +void mach_probe_callback(); diff --git a/src/pwm_spindle.c b/src/pwm_spindle.c index 196319d..56017e9 100644 --- a/src/pwm_spindle.c +++ b/src/pwm_spindle.c @@ -53,7 +53,7 @@ static spindle_t spindle = { }; -static void _spindle_set_pwm(cmSpindleMode_t mode, float speed) { +static void _spindle_set_pwm(machSpindleMode_t mode, float speed) { if (mode == SPINDLE_OFF || speed < spindle.min_rpm) { TIMER_PWM.CTRLA = 0; return; @@ -120,7 +120,7 @@ void pwm_spindle_init() { } -void pwm_spindle_set(cmSpindleMode_t mode, float speed) { +void pwm_spindle_set(machSpindleMode_t mode, float speed) { _spindle_set_dir(mode == SPINDLE_CW); _spindle_set_pwm(mode, speed); _spindle_set_enable(mode != SPINDLE_OFF && TIMER_PWM.CTRLA); diff --git a/src/pwm_spindle.h b/src/pwm_spindle.h index 6e739b3..89c6fe1 100644 --- a/src/pwm_spindle.h +++ b/src/pwm_spindle.h @@ -31,4 +31,4 @@ void pwm_spindle_init(); -void pwm_spindle_set(cmSpindleMode_t mode, float speed); +void pwm_spindle_set(machSpindleMode_t mode, float speed); diff --git a/src/spindle.c b/src/spindle.c index 7d1dcfd..5e02a41 100644 --- a/src/spindle.c +++ b/src/spindle.c @@ -43,7 +43,7 @@ typedef enum { static spindleType_t spindle_type = SPINDLE_TYPE; -static void _spindle_set(cmSpindleMode_t mode, float speed) { +static void _spindle_set(machSpindleMode_t mode, float speed) { switch (spindle_type) { case SPINDLE_TYPE_PWM: pwm_spindle_set(mode, speed); break; case SPINDLE_TYPE_HUANYANG: huanyang_set(mode, speed); break; @@ -53,35 +53,35 @@ static void _spindle_set(cmSpindleMode_t mode, float speed) { /// execute the spindle command (called from planner) static void _exec_spindle_control(float *value, float *flag) { - cmSpindleMode_t mode = value[0]; - cm_set_spindle_mode(mode); - _spindle_set(mode, cm.gm.spindle_speed); + machSpindleMode_t mode = value[0]; + mach_set_spindle_mode(mode); + _spindle_set(mode, mach.gm.spindle_speed); } /// Spindle speed callback from planner queue static void _exec_spindle_speed(float *value, float *flag) { float speed = value[0]; - cm_set_spindle_speed_parameter(speed); - _spindle_set(cm.gm.spindle_mode, speed); + mach_set_spindle_speed_parameter(speed); + _spindle_set(mach.gm.spindle_mode, speed); } -void cm_spindle_init() { +void mach_spindle_init() { pwm_spindle_init(); huanyang_init(); } /// Queue the spindle command to the planner buffer -void cm_spindle_control(cmSpindleMode_t mode) { +void mach_spindle_control(machSpindleMode_t mode) { float value[AXES] = {mode}; mp_queue_command(_exec_spindle_control, value, value); } /// Queue the S parameter to the planner buffer -void cm_set_spindle_speed(float speed) { +void mach_set_spindle_speed(float speed) { float value[AXES] = {speed}; mp_queue_command(_exec_spindle_speed, value, value); } @@ -96,6 +96,6 @@ void set_spindle_type(int index, uint8_t value) { if (value != spindle_type) { _spindle_set(SPINDLE_OFF, 0); spindle_type = value; - _spindle_set(cm.gm.spindle_mode, cm.gm.spindle_speed); + _spindle_set(mach.gm.spindle_mode, mach.gm.spindle_speed); } } diff --git a/src/spindle.h b/src/spindle.h index 0b78a2f..36f7800 100644 --- a/src/spindle.h +++ b/src/spindle.h @@ -31,6 +31,6 @@ #include "machine.h" -void cm_spindle_init(); -void cm_set_spindle_speed(float speed); // S parameter -void cm_spindle_control(cmSpindleMode_t spindle_mode); // M3, M4, M5 +void mach_spindle_init(); +void mach_set_spindle_speed(float speed); // S parameter +void mach_spindle_control(machSpindleMode_t spindle_mode); // M3, M4, M5 diff --git a/src/switch.c b/src/switch.c index 9014f30..c9279c2 100644 --- a/src/switch.c +++ b/src/switch.c @@ -169,8 +169,8 @@ void switch_rtc_callback() { if (s->cb) s->cb(i, s->state); // TODO fix this - if (cm.cycle_state == CYCLE_HOMING || cm.cycle_state == CYCLE_PROBE) - cm_request_feedhold(); + if (mach.cycle_state == CYCLE_HOMING || mach.cycle_state == CYCLE_PROBE) + mach_request_feedhold(); } } } -- 2.27.0