Пример #1
0
static int8_t _get_next_axis(int8_t axis)
{
	if (axis == -1) {	// inelegant brute force solution
		if (fp_TRUE(gf.target[AXIS_Z])) return (AXIS_Z);
		if (fp_TRUE(gf.target[AXIS_X])) return (AXIS_X);
		if (fp_TRUE(gf.target[AXIS_Y])) return (AXIS_Y);
		if (fp_TRUE(gf.target[AXIS_A])) return (AXIS_A);
//		if (fp_TRUE(gf.target[AXIS_B])) return (AXIS_B);
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
		return (-2);	// error
	} else if (axis == AXIS_Z) {
		if (fp_TRUE(gf.target[AXIS_X])) return (AXIS_X);
		if (fp_TRUE(gf.target[AXIS_Y])) return (AXIS_Y);
		if (fp_TRUE(gf.target[AXIS_A])) return (AXIS_A);
//		if (fp_TRUE(gf.target[AXIS_B])) return (AXIS_B);
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
	} else if (axis == AXIS_X) {
		if (fp_TRUE(gf.target[AXIS_Y])) return (AXIS_Y);
		if (fp_TRUE(gf.target[AXIS_A])) return (AXIS_A);
//		if (fp_TRUE(gf.target[AXIS_B])) return (AXIS_B);
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
	} else if (axis == AXIS_Y) {
		if (fp_TRUE(gf.target[AXIS_A])) return (AXIS_A);
//		if (fp_TRUE(gf.target[AXIS_B])) return (AXIS_B);
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
//	} else if (axis == AXIS_A) {
//		if (fp_TRUE(gf.target[AXIS_B])) return (AXIS_B);
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
//	} else if (axis == AXIS_B) {
//		if (fp_TRUE(gf.target[AXIS_C])) return (AXIS_C);
	}
	return (-1);	// done
}
Пример #2
0
static stat_t _probing_finish()
{
    int8_t probe = gpio_read_input(pb.probe_input);
	cm.probe_state = (probe==true) ? PROBE_SUCCEEDED : PROBE_FAILED;

	for (uint8_t axis=0; axis<AXES; axis++ ) {
		// if we got here because of a feed hold we need to keep the model position correct
		cm_set_position(axis, cm_get_work_position(RUNTIME, axis));

		// store the probe results
		cm.probe_results[axis] = cm_get_absolute_position(ACTIVE_MODEL, axis);
	}

	// If probe was successful the 'e' word == 1, otherwise e == 0 to signal an error
	printf_P(PSTR("{\"prb\":{\"e\":%i"), (int)cm.probe_state);
	if (fp_TRUE(pb.flags[AXIS_X])) printf_P(PSTR(",\"x\":%0.3f"), cm.probe_results[AXIS_X]);
	if (fp_TRUE(pb.flags[AXIS_Y])) printf_P(PSTR(",\"y\":%0.3f"), cm.probe_results[AXIS_Y]);
	if (fp_TRUE(pb.flags[AXIS_Z])) printf_P(PSTR(",\"z\":%0.3f"), cm.probe_results[AXIS_Z]);
	if (fp_TRUE(pb.flags[AXIS_A])) printf_P(PSTR(",\"a\":%0.3f"), cm.probe_results[AXIS_A]);
	if (fp_TRUE(pb.flags[AXIS_B])) printf_P(PSTR(",\"b\":%0.3f"), cm.probe_results[AXIS_B]);
	if (fp_TRUE(pb.flags[AXIS_C])) printf_P(PSTR(",\"c\":%0.3f"), cm.probe_results[AXIS_C]);
	printf_P(PSTR("}}\n"));

	return (_set_pb_func(_probing_finalize_exit));
}
Пример #3
0
static uint8_t _probing_init()
{
    float start_position[AXES];

    // so optimistic... ;)
    // NOTE: it is *not* an error condition for the probe not to trigger.
    // it is an error for the limit or homing switches to fire, or for some other configuration error.
    cm.probe_state = PROBE_FAILED;
    cm.machine_state = MACHINE_CYCLE;
    cm.cycle_state = CYCLE_PROBE;

    // save relevant non-axis parameters from Gcode model
    pb.saved_coord_system = cm_get_coord_system(ACTIVE_MODEL);
    pb.saved_distance_mode = cm_get_distance_mode(ACTIVE_MODEL);

    // set working values
    cm_set_distance_mode(ABSOLUTE_MODE);
    cm_set_coord_system(ABSOLUTE_COORDS);   // probing is done in machine coordinates

    // initialize the axes - save the jerk settings & switch to the jerk_homing settings
    for( uint8_t axis=0; axis<AXES; axis++ ) {
        pb.saved_jerk[axis] = cm_get_axis_jerk(axis);	// save the max jerk value
        cm_set_axis_jerk(axis, cm.a[axis].jerk_high);	// use the high-speed jerk for probe
        start_position[axis] = cm_get_absolute_position(ACTIVE_MODEL, axis);
    }

    // error if the probe target is too close to the current position
    if (get_axis_vector_length(start_position, pb.target) < MINIMUM_PROBE_TRAVEL) {
        _probing_error_exit(-2);
    }

	// error if the probe target requires a move along the A/B/C axes
	for ( uint8_t axis=AXIS_A; axis<AXES; axis++ ) {
//		if (fp_NE(start_position[axis], pb.target[axis])) { // old style
		if (fp_TRUE(pb.flags[axis])) {
//		if (pb.flags[axis]) {           // will reduce to this once flags are booleans
   			_probing_error_exit(axis);
        }
	}

	// initialize the probe switch
    pb.probe_input = 5;     // TODO -- for now we hard code it to zmin
    gpio_set_probing_mode(pb.probe_input, true);

    // turn off spindle and start the move
    cm_spindle_optional_pause(true);        // pause the spindle if it's on
	return (_set_pb_func(_probing_start));	// start the probe move
}