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;
}
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);
}
// 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
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
#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
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;
// 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) {
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);
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);
}
* 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.
*/
*/
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
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;
}
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);
/// 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;
}
/// 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;
}
// 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;
}
// 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));
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
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
}
#include <stdbool.h>
-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();
bool connected;
bool changed;
- cmSpindleMode_t mode;
+ machSpindleMode_t mode;
float speed;
float actual_freq;
}
-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);
// 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;
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();
* 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
#include <stdio.h>
-cmSingleton_t cm = {
+machSingleton_t mach = {
// Offsets
.offset = {
{}, // ABSOLUTE_COORDS
// 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
*/
/// 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);
}
* 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:
* 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);
}
* 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];
}
* 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;
}
* 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;
}
* 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)
* 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
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);
}
// 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;
}
}
/* 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
* 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
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;
/// 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;
}
// 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
* 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]);
}
// (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};
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
}
* 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();
* 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
}
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();
*/
/// 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);
}
// 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);
}
/// 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;
}
*/
/// 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
*/
/// 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);
}
* 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
/// 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();
}
}
-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
/* 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)
* 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)
* + 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);
}
/// 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];
#include <stdbool.h>
-#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
*
* 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:
*
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 {
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 {
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
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
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
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
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)
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 {
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
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 {
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
SPINDLE_OFF,
SPINDLE_CW,
SPINDLE_CCW
-} cmSpindleMode_t;
+} machSpindleMode_t;
/// mist and flood coolant states
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:
* 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
* 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().
*/
/// 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)
} 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
} 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
// 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
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);
// 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();
// 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;
// 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;
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
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;
MOTOR_FLAG_OVERTEMP_WARN_bm |
MOTOR_FLAG_OVERTEMP_bm |
MOTOR_FLAG_SHORTED_bm)
-} cmMotorFlags_t;
+} machMotorFlags_t;
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();
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);
*/
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));
}
*/
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
// 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
// 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
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);
* 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
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;
// 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;
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;
// 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
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 =
// 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;
}
*
* 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] =
}
-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;
}
#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();
// 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);
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;
\******************************************************************************/
/* How this works:
- * - A command is called by the Gcode interpreter (cm_<command>, 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_<command>,
+ * 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()
/// 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) {
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++) {
}
// 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();
}
#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);
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;
}
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;
}
// 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 {
// 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)
// 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;
}
// 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();
}
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;
// 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
#include <stdbool.h>
#include <math.h>
-/* 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.
*
* 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
/// 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
_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;
}
_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;
}
}
// 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;
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
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);
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
// 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
// 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;
}
// 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
// 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
}
* "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.
*
* 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);
}
// 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);
}
}
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.
* 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.
*/
// 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;
}
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();
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);
}
// 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
_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
// 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;
/// 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
}
#include <stdbool.h>
-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();
};
-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;
}
-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);
void pwm_spindle_init();
-void pwm_spindle_set(cmSpindleMode_t mode, float speed);
+void pwm_spindle_set(machSpindleMode_t mode, float speed);
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;
/// 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);
}
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);
}
}
#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
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();
}
}
}
projects / bbctrl-firmware / commitdiff