mirror/Grbl_Esp32
1
0
Fork 0
mirror of https://github.com/bdring/Grbl_Esp32.git synced 2025-09-02 10:53:01 +02:00
Code Issues Releases Wiki Activity

Fixed typo

Browse Source
This commit is contained in:
Mitch Bradley
2020-12-22 20:52:14 -10:00
parent f6df8cd701
commit c43f479342
5 changed files with 138 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
Grbl_Esp32/Custom/CoreXY.cpp
View File

@@ -134,7 +134,7 @@ bool user_defined_homing(uint8_t cycle_mask) {
// convert back to motor steps
inverse_kinematics(target);
pl_data->feed_rate = homing_rate; // feed or seek rates
pl_data->feed_rate = homing_rate; // Set current homing rate.
plan_buffer_line(target, pl_data); // Bypass mc_line(). Directly plan homing motion.
sys.step_control = {};
sys.step_control.executeSysMotion = true; // Set to execute homing motion and clear existing flags.
@@ -148,23 +148,18 @@ bool user_defined_homing(uint8_t cycle_mask) {
st_prep_buffer(); // Check and prep segment buffer. NOTE: Should take no longer than 200us.
// Exit routines: No time to run protocol_execute_realtime() in this loop.
if (sys_safetyDoor || sys_reset || sys_cycleStop) {
ExecState rt_exec_state;
rt_exec_state.value = sys_get_rt_exec_state().value;
if (sys_reset) {
// Homing failure condition: Reset issued during cycle.
if (rt_exec_state.bit.reset) {
sys_rt_exec_alarm = ExecAlarm::HomingFailReset;
}
} else if (sys_safetyDoor) {
// Homing failure condition: Safety door was opened.
if (rt_exec_state.bit.safetyDoor) {
sys_rt_exec_alarm = ExecAlarm::HomingFailDoor;
}
// Homing failure condition: Limit switch still engaged after pull-off motion
if (!approach && (limits_get_state() & cycle_mask)) {
sys_rt_exec_alarm = ExecAlarm::HomingFailPulloff;
}
} else if (approach) { // sys_cycleStop must be true if we get this far
// Homing failure condition: Limit switch not found during approach.
if (approach && rt_exec_state.bit.cycleStop) {
sys_rt_exec_alarm = ExecAlarm::HomingFailApproach;
} else if (limits_get_state() & cycle_mask) {
// Homing failure condition: Limit switch still engaged after pull-off motion
sys_rt_exec_alarm = ExecAlarm::HomingFailPulloff;
}
if (sys_rt_exec_alarm != ExecAlarm::None) {
@@ -172,12 +167,12 @@ bool user_defined_homing(uint8_t cycle_mask) {
mc_reset(); // Stop motors, if they are running.
protocol_execute_realtime();
return true;
} else {
}
// Pull-off motion complete. Disable CYCLE_STOP from executing.
sys_cycleStop = false;
break;
}
}
} while (!switch_touched);
#ifdef USE_I2S_STEPS

21
Grbl_Esp32/src/Limits.cpp
View File

@@ -174,23 +174,18 @@ void limits_go_home(uint8_t cycle_mask) {
st_prep_buffer(); // Check and prep segment buffer. NOTE: Should take no longer than 200us.
// Exit routines: No time to run protocol_execute_realtime() in this loop.
if (sys_safetyDoor || sys_reset || sys_cycleStop) {
ExecState rt_exec_state;
rt_exec_state.value = sys_get_rt_exec_state().value;
if (sys_reset) {
// Homing failure condition: Reset issued during cycle.
if (rt_exec_state.bit.reset) {
sys_rt_exec_alarm = ExecAlarm::HomingFailReset;
}
} else if (sys_safetyDoor) {
// Homing failure condition: Safety door was opened.
if (rt_exec_state.bit.safetyDoor) {
sys_rt_exec_alarm = ExecAlarm::HomingFailDoor;
}
// Homing failure condition: Limit switch still engaged after pull-off motion
if (!approach && (limits_get_state() & cycle_mask)) {
sys_rt_exec_alarm = ExecAlarm::HomingFailPulloff;
}
} else if (approach) { // sys_cycleStop must be true if we get this far
// Homing failure condition: Limit switch not found during approach.
if (approach && rt_exec_state.bit.cycleStop) {
sys_rt_exec_alarm = ExecAlarm::HomingFailApproach;
} else if (limits_get_state() & cycle_mask) {
// Homing failure condition: Limit switch still engaged after pull-off motion
sys_rt_exec_alarm = ExecAlarm::HomingFailPulloff;
}
if (sys_rt_exec_alarm != ExecAlarm::None) {
@@ -198,12 +193,12 @@ void limits_go_home(uint8_t cycle_mask) {
mc_reset(); // Stop motors, if they are running.
protocol_execute_realtime();
return;
} else {
}
// Pull-off motion complete. Disable CYCLE_STOP from executing.
sys_cycleStop = false;
break;
}
}
} while (STEP_MASK & axislock);
#ifdef USE_I2S_STEPS
if (current_stepper == ST_I2S_STREAM) {

28
Grbl_Esp32/src/Protocol.cpp
View File

@@ -270,22 +270,20 @@ void protocol_exec_rt_system() {
}
sys_rt_exec_alarm = ExecAlarm::None;
}
ExecState rt_exec_state;
rt_exec_state.value = sys_get_rt_exec_state().value; // Copy volatile sys_rt_exec_state.
if (rt_exec_state.value != 0) { // Test if any bits are on
// Execute system abort.
if (rt_exec_state.bit.reset) {
if (sys_reset) {
sys.abort = true; // Only place this is set true.
return; // Nothing else to do but exit.
}
// Execute and serial print status
if (rt_exec_state.bit.statusReport) {
if (sys_statusReport) {
report_realtime_status(CLIENT_ALL);
sys_statusReport = false;
}
// NOTE: Once hold is initiated, the system immediately enters a suspend state to block all
// main program processes until either reset or resumed. This ensures a hold completes safely.
if (rt_exec_state.bit.motionCancel || rt_exec_state.bit.feedHold || rt_exec_state.bit.safetyDoor || rt_exec_state.bit.sleep) {
if (sys_motionCancel || sys_feedHold || sys_safetyDoor || sys_sleep) {
// State check for allowable states for hold methods.
if (!(sys.state == State::Alarm || sys.state == State::CheckMode)) {
// If in CYCLE or JOG states, immediately initiate a motion HOLD.
@@ -295,7 +293,7 @@ void protocol_exec_rt_system() {
sys.step_control = {};
sys.step_control.executeHold = true; // Initiate suspend state with active flag.
if (sys.state == State::Jog) { // Jog cancelled upon any hold event, except for sleeping.
if (!rt_exec_state.bit.sleep) {
if (!sys_sleep) {
sys.suspend.bit.jogCancel = true;
}
}
@@ -308,7 +306,7 @@ void protocol_exec_rt_system() {
}
// Execute and flag a motion cancel with deceleration and return to idle. Used primarily by probing cycle
// to halt and cancel the remainder of the motion.
if (rt_exec_state.bit.motionCancel) {
if (sys_motionCancel) {
// MOTION_CANCEL only occurs during a CYCLE, but a HOLD and SAFETY_DOOR may been initiated beforehand
// to hold the CYCLE. Motion cancel is valid for a single planner block motion only, while jog cancel
// will handle and clear multiple planner block motions.
@@ -318,7 +316,7 @@ void protocol_exec_rt_system() {
sys_motionCancel = false;
}
// Execute a feed hold with deceleration, if required. Then, suspend system.
if (rt_exec_state.bit.feedHold) {
if (sys_feedHold) {
// Block SAFETY_DOOR, JOG, and SLEEP states from changing to HOLD state.
if (!(sys.state == State::SafetyDoor || sys.state == State::Jog || sys.state == State::Sleep)) {
sys.state = State::Hold;
@@ -328,7 +326,7 @@ void protocol_exec_rt_system() {
// Execute a safety door stop with a feed hold and disable spindle/coolant.
// NOTE: Safety door differs from feed holds by stopping everything no matter state, disables powered
// devices (spindle/coolant), and blocks resuming until switch is re-engaged.
if (rt_exec_state.bit.safetyDoor) {
if (sys_safetyDoor) {
report_feedback_message(Message::SafetyDoorAjar);
// If jogging, block safety door methods until jog cancel is complete. Just flag that it happened.
if (!(sys.suspend.bit.jogCancel)) {
@@ -362,7 +360,7 @@ void protocol_exec_rt_system() {
sys.suspend.bit.safetyDoorAjar = true;
}
}
if (rt_exec_state.bit.sleep) {
if (sys_sleep) {
if (sys.state == State::Alarm) {
sys.suspend.bit.retractComplete = true;
sys.suspend.bit.holdComplete = true;
@@ -370,12 +368,12 @@ void protocol_exec_rt_system() {
sys.state = State::Sleep;
sys_sleep = false;
}
}
// Execute a cycle start by starting the stepper interrupt to begin executing the blocks in queue.
if (rt_exec_state.bit.cycleStart) {
if (sys_cycleStart) {
// Block if called at same time as the hold commands: feed hold, motion cancel, and safety door.
// Ensures auto-cycle-start doesn't resume a hold without an explicit user-input.
if (!(rt_exec_state.bit.feedHold || rt_exec_state.bit.motionCancel || rt_exec_state.bit.safetyDoor)) {
if (!(sys_feedHold || sys_motionCancel || sys_safetyDoor)) {
// Resume door state when parking motion has retracted and door has been closed.
if (sys.state == State::SafetyDoor && !(sys.suspend.bit.safetyDoorAjar)) {
if (sys.suspend.bit.restoreComplete) {
@@ -410,7 +408,7 @@ void protocol_exec_rt_system() {
}
sys_cycleStart = false;
}
if (rt_exec_state.bit.cycleStop) {
if (sys_cycleStop) {
// Reinitializes the cycle plan and stepper system after a feed hold for a resume. Called by
// realtime command execution in the main program, ensuring that the planner re-plans safely.
// NOTE: Bresenham algorithm variables are still maintained through both the planner and stepper

14
Grbl_Esp32/src/System.cpp
View File

@@ -343,20 +343,6 @@ uint8_t sys_calc_pwm_precision(uint32_t freq) {
return precision - 1;
}
ExecState sys_get_rt_exec_state() {
ExecState result;
result.value = 0;
result.bit.statusReport = sys_statusReport;
result.bit.cycleStart = sys_cycleStart;
result.bit.cycleStop = sys_cycleStop;
result.bit.feedHold = sys_feedHold;
result.bit.reset = sys_reset;
result.bit.safetyDoor = sys_safetyDoor;
result.bit.motionCancel = sys_motionCancel;
result.bit.sleep = sys_sleep;
return result;
}
void __attribute__((weak)) user_defined_macro(uint8_t index) {
// must be in Idle
if (sys.state != State::Idle) {

2
Grbl_Esp32/src/System.h
View File

@@ -185,5 +185,3 @@ bool sys_pwm_control(uint8_t io_num_mask, float duty, bool synchronized);
int8_t sys_get_next_PWM_chan_num();
uint8_t sys_calc_pwm_precision(uint32_t freq);
ExecState sys_get_rt_exec_state();