bdurbrow
commented
5 years ago Um... that's really kinda sketchy. I think you'd be better off adding limit switches to the endstops.
However, if you really, really must... look at limits.c; specifically limits_go_home().
What you will need to do is remove all the stuff that checks the limit switches, and performs pull-off moves once the limits are found.
This is completely untested; so may not work -- but, I think it should look something like this:
void limits_go_home(uint8_t cycle_mask)
{
if (sys.abort) { return; } // Block if system reset has been issued.
// Initialize plan data struct for homing motion. Spindle and coolant are disabled.
plan_line_data_t plan_data;
plan_line_data_t *pl_data = &plan_data;
memset(pl_data,0,sizeof(plan_line_data_t));
pl_data->condition = (PL_COND_FLAG_SYSTEM_MOTION|PL_COND_FLAG_NO_FEED_OVERRIDE);
#ifdef USE_LINE_NUMBERS
pl_data->line_number = HOMING_CYCLE_LINE_NUMBER;
#endif
float max_travel = 0.0;
uint8_t n_active_axis = 0;
for (uint8_t idx=0; idx<N_AXIS; idx++)
{
if (bit_istrue(cycle_mask,bit(idx)))
{
// Set target based on max_travel setting. Ensure homing switches engaged with search scalar.
// NOTE: settings.max_travel[] is stored as a negative value.
max_travel = max(max_travel,(-HOMING_AXIS_SEARCH_SCALAR)*settings.max_travel[idx]);
n_active_axis++;
}
}
float target[N_AXIS];
system_convert_array_steps_to_mpos(target,sys_position);
for (idx=0; idx<N_AXIS; idx++)
{
// Set target location for active axes and setup computation for homing rate.
if (bit_istrue(cycle_mask,bit(idx)))
{
sys_position[idx] = 0;
// Set target direction based on cycle mask and homing cycle approach state.
// NOTE: This happens to compile smaller than any other implementation tried.
if (bit_istrue(settings.homing_dir_mask,bit(idx)))
{
target[idx] = -max_travel;
}
else
{
target[idx] = max_travel;
}
}
}
// Perform homing cycle. Planner buffer should be empty, as required to initiate the homing cycle.
float homing_rate = settings.homing_seek_rate;
homing_rate *= sqrt(n_active_axis); // [sqrt(N_AXIS)] Adjust so individual axes all move at homing rate.
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 = STEP_CONTROL_EXECUTE_SYS_MOTION; // Set to execute homing motion and clear existing flags.
st_prep_buffer(); // Prep and fill segment buffer from newly planned block.
st_wake_up(); // Initiate motion
do
{
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_rt_exec_state & (EXEC_SAFETY_DOOR | EXEC_RESET | EXEC_CYCLE_STOP))
{
uint8_t rt_exec = sys_rt_exec_state;
// Homing failure condition: Reset issued during cycle.
if (rt_exec & EXEC_RESET) { system_set_exec_alarm(EXEC_ALARM_HOMING_FAIL_RESET); }
// Homing failure condition: Safety door was opened.
if (rt_exec & EXEC_SAFETY_DOOR) { system_set_exec_alarm(EXEC_ALARM_HOMING_FAIL_DOOR); }
// Homing failure condition: Limit switch not found during approach.
if (sys_rt_exec_alarm)
{
mc_reset(); // Stop motors, if they are running.
protocol_execute_realtime();
return;
}
}
} while (!(rt_exec & EXEC_CYCLE_STOP));
// The active cycle axes should now be homed and machine limits have been located. By
// default, Grbl defines machine space as all negative, as do most CNCs. Since limit stops
// can be on either side of an axes, check and set axes machine zero appropriately.
int32_t set_axis_position;
// Set machine positions for homed limit switches. Don't update non-homed axes.
for (idx=0; idx<N_AXIS; idx++)
{
// NOTE: settings.max_travel[] is stored as a negative value.
if (cycle_mask & bit(idx))
{
#ifdef HOMING_FORCE_SET_ORIGIN
set_axis_position = 0;
#else
if ( bit_istrue(settings.homing_dir_mask,bit(idx)) )
{
set_axis_position = lround((settings.max_travel[idx]+settings.homing_pulloff)*settings.steps_per_mm[idx]);
}
else
{
set_axis_position = lround(-settings.homing_pulloff*settings.steps_per_mm[idx]);
}
#endif
sys_position[idx] = set_axis_position;
}
}
sys.step_control = STEP_CONTROL_NORMAL_OP; // Return step control to normal operation.
}
SketchThis
drf5n
Like the title says, is it possible to home a GRBL machine with no limit switches?
Let me explain: I have a CNC I'm converting and it homes itself by jogging each axis farther than it can physically go.
To home each axis there's a hard stop at Z zero, X 12 and Y 12.
The machine's max Z travel is 3 inches, so on homing it jogs up 4 inches and hits the end stop. It backs off .125" and is zero'd there.
Same for X and Y, they're jogged to 13 inches (1" more than the max travel) so they hit the end stop. After that 13" move they're jogged negatively 12" and zero'd there.
Is it possible to set something like this up in GRBLs native homing routine? I'm sure I go do it manually with native G Code commands, but I'd like to have the homing buttons actually work...