axis homing error if $21 disabled

uCNC/src/cnc.c

@@ -387,7 +387,7 @@ MCU_CALLBACK void mcu_rtc_cb(uint32_t millis)
 }
 #endif
 
-void cnc_home(void)
+uint8_t cnc_home(void)
 {
 	cnc_set_exec_state(EXEC_HOMING);
 	uint8_t error = kinematics_home();
@@ -409,6 +409,8 @@ void cnc_home(void)
 	{
 		cnc_run_startup_blocks();
 	}
+
+	return error;
 }
 
 void cnc_alarm(int8_t code)

uCNC/src/cnc.h

@@ -165,7 +165,7 @@ extern "C"
 	void cnc_run(void);
 	// do events returns true if all OK and false if an ABORT alarm is reached
 	bool cnc_dotasks(void);
-	void cnc_home(void);
+	uint8_t cnc_home(void);
 	void cnc_alarm(int8_t code);
 	bool cnc_has_alarm(void);
 	uint8_t cnc_get_alarm(void);

uCNC/src/core/motion_control.c

@@ -771,7 +771,10 @@ bool mc_home_motion(uint8_t axis_mask, bool is_origin_search, motion_data_t *blo
 		}
 	}
 
-	cnc_unlock(true);
+	if (cnc_unlock(true) != UNLOCK_OK)
+	{
+		return false;
+	}
 	mc_line(target, block_data);
 
 	if (itp_sync() != STATUS_OK)

uCNC/src/core/parser.c

@@ -699,17 +699,15 @@ static uint8_t parser_grbl_exec_code(uint8_t code)
 			return STATUS_SETTING_DISABLED;
 		}
 
-		if (cnc_unlock(true) == UNLOCK_OK)
-		{
 #if ASSERT_PIN(SAFETY_DOOR)
-			if (cnc_get_exec_state(EXEC_DOOR))
-			{
-				return STATUS_CHECK_DOOR;
-			}
-#endif
-			cnc_home();
+		cnc_clear_exec_state(EXEC_DOOR);
+		if (cnc_get_exec_state(EXEC_DOOR))
+		{
+			return STATUS_CHECK_DOOR;
 		}
-		break;
+#endif
+		return cnc_home();
+
 	case GRBL_HELP:
 		proto_print(MSG_HELP);
 		break;
@@ -949,7 +947,7 @@ static uint8_t parser_validate_command(parser_state_t *new_state, parser_words_t
 {
 	bool requires_feed = true;
 	bool has_axis = CHECKFLAG(cmd->words, GCODE_ALL_AXIS);
-	
+
 	// only alow groups 3, 6 and modal G53
 	if (cnc_get_exec_state(EXEC_JOG))
 	{

uCNC/src/hal/kinematics/kinematic_cartesian.c

@@ -46,70 +46,80 @@ void kinematics_apply_forward(int32_t *steps, float *axis)
 uint8_t kinematics_home(void)
 {
 	float target[AXIS_COUNT];
+	uint8_t error = STATUS_OK;
 
 #ifndef DISABLE_ALL_LIMITS
 #if AXIS_Z_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Z;
+		return error;
 	}
 #endif
 
 #ifndef ENABLE_XY_SIMULTANEOUS_HOMING
 
 #if AXIS_X_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_X;
+		return error;
 	}
 #endif
 
 #if AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Y;
+		return error;
 	}
 #endif
 
 #else
 
 #if AXIS_X_HOMING_MASK != 0 && AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK | AXIS_Y_HOMING_MASK, LINACT0_LIMIT_MASK | LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK | AXIS_Y_HOMING_MASK, LINACT0_LIMIT_MASK | LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_XY;
+		return error;
 	}
 #elif AXIS_X_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_X;
+		return error;
 	}
 #elif AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Y;
+		return error;
 	}
 #endif
 
 #endif
 
 #if AXIS_A_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK))
+	error = mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_A;
+		return error;
 	}
 #endif
 
 #if AXIS_B_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK))
+	error = mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_B;
+		return error;
 	}
 #endif
 
 #if AXIS_C_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK))
+	error = mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_C;
+		return error;
 	}
 #endif
 
@@ -126,24 +136,24 @@ uint8_t kinematics_home(void)
 	block_data.spindle = 0;
 	block_data.dwell = 0;
 	// starts offset and waits to finnish
-	mc_line(target, &block_data);
+	error = mc_line(target, &block_data);
 	itp_sync();
 #endif
 
 #ifdef SET_ORIGIN_AT_HOME_POS
 	memset(target, 0, sizeof(target));
 #else
-for (uint8_t i = AXIS_COUNT; i != 0;)
-{
-	i--;
-	target[i] = (!(g_settings.homing_dir_invert_mask & (1 << i)) ? 0 : g_settings.max_distance[i]);
-}
+	for (uint8_t i = AXIS_COUNT; i != 0;)
+	{
+		i--;
+		target[i] = (!(g_settings.homing_dir_invert_mask & (1 << i)) ? 0 : g_settings.max_distance[i]);
+	}
 #endif
 
 	// reset position
 	itp_reset_rt_position(target);
 
-	return STATUS_OK;
+	return error;
 }
 
 bool kinematics_check_boundaries(float *axis)

uCNC/src/hal/kinematics/kinematic_corexy.c

@@ -83,70 +83,80 @@ void kinematics_apply_forward(int32_t *steps, float *axis)
 uint8_t kinematics_home(void)
 {
 	float target[AXIS_COUNT];
+	uint8_t error = STATUS_OK;
 
 #ifndef DISABLE_ALL_LIMITS
 #if AXIS_Z_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Z;
+		return error;
 	}
 #endif
 
 #ifndef ENABLE_XY_SIMULTANEOUS_HOMING
 
 #if AXIS_X_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_X;
+		return error;
 	}
 #endif
 
 #if AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Y;
+		return error;
 	}
 #endif
 
 #else
 
 #if AXIS_X_HOMING_MASK != 0 && AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK | AXIS_Y_HOMING_MASK, LINACT0_LIMIT_MASK | LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK | AXIS_Y_HOMING_MASK, LINACT0_LIMIT_MASK | LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_XY;
+		return error;
 	}
 #elif AXIS_X_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_X;
+		return error;
 	}
 #elif AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Y;
+		return error;
 	}
 #endif
 
 #endif
 
 #if AXIS_A_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK))
+	error = mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_A;
+		return error;
 	}
 #endif
 
 #if AXIS_B_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK))
+	error = mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_B;
+		return error;
 	}
 #endif
 
 #if AXIS_C_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK))
+	error = mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_C;
+		return error;
 	}
 #endif
 
@@ -164,7 +174,7 @@ uint8_t kinematics_home(void)
 	block_data.spindle = 0;
 	block_data.dwell = 0;
 	// starts offset and waits to finnish
-	mc_line(target, &block_data);
+	error = mc_line(target, &block_data);
 	itp_sync();
 #endif
 
@@ -181,7 +191,7 @@ uint8_t kinematics_home(void)
 	// reset position
 	itp_reset_rt_position(target);
 
-	return STATUS_OK;
+	return error;
 }
 
 bool kinematics_check_boundaries(float *axis)

uCNC/src/hal/kinematics/kinematic_delta.c

@@ -326,6 +326,8 @@ uint8_t kinematics_home(void)
 {
 	// delta starts by invalidating the current position and considers it's at the far end of the homing position
 	float axis[AXIS_COUNT];
+	uint8_t error = STATUS_OK;
+
 	// reset home offset
 	delta_cuboid_z_home = 0;
 	// reset coordinates
@@ -335,30 +337,34 @@ uint8_t kinematics_home(void)
 	// sync interpolator to new position (motion homing syncs remaining systems)
 	itp_reset_rt_position(axis);
 
-	if (mc_home_axis(AXIS_Z_MASK, LIMITS_DELTA_MASK))
+	error = mc_home_axis(AXIS_Z_HOMING_MASK, LIMITS_DELTA_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Z;
+		return error;
 	}
 
 
 #if AXIS_A_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK))
+	error = mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_A;
+		return error;
 	}
 #endif
 
 #if AXIS_B_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK))
+	error = mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_B;
+		return error;
 	}
 #endif
 
 #if AXIS_C_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK))
+	error = mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_C;
+		return error;
 	}
 #endif
 
@@ -380,7 +386,7 @@ uint8_t kinematics_home(void)
 	block_data.spindle = 0;
 	block_data.dwell = 0;
 	// starts offset and waits to finnish
-	mc_line(target, &block_data);
+	error = mc_line(target, &block_data);
 	itp_sync();
 
 // add the internal offset to the kinematics
@@ -395,7 +401,7 @@ uint8_t kinematics_home(void)
 	itp_reset_rt_position(target);
 	mc_sync_position();
 
-	return STATUS_OK;
+	return error;
 }
 
 bool kinematics_check_boundaries(float *axis)

uCNC/src/hal/kinematics/kinematic_linear_delta.c

@@ -145,30 +145,34 @@ void kinematics_apply_forward(int32_t *steps, float *axis)
 
 uint8_t kinematics_home(void)
 {
-	if (mc_home_axis(AXIS_Z_MASK, LIMITS_DELTA_MASK))
+	uint8_t error = mc_home_axis(AXIS_Z_HOMING_MASK, LIMITS_DELTA_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Z;
+		return error;
 	}
 
 
 #if AXIS_A_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK))
+	error = mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_A;
+		return error;
 	}
 #endif
 
 #if AXIS_B_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK))
+	error = mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_B;
+		return error;
 	}
 #endif
 
 #if AXIS_C_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK))
+	error = mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_C;
+		return error;
 	}
 #endif
 
@@ -185,7 +189,7 @@ uint8_t kinematics_home(void)
 	block_data.spindle = 0;
 	block_data.dwell = 0;
 	// starts offset and waits to finnish
-	mc_line(target, &block_data);
+	error = mc_line(target, &block_data);
 	itp_sync();
 
 	memset(target, 0, sizeof(target));
@@ -199,7 +203,7 @@ uint8_t kinematics_home(void)
 	// reset position
 	itp_reset_rt_position(target);
 
-	return STATUS_OK;
+	return error;
 }
 
 bool kinematics_check_boundaries(float *axis)

uCNC/src/hal/kinematics/kinematic_scara.c

@@ -97,47 +97,54 @@ void kinematics_apply_forward(int32_t *steps, float *axis)
 uint8_t kinematics_home(void)
 {
 	float target[AXIS_COUNT];
+	uint8_t error = STATUS_OK;
 
 #ifndef DISABLE_ALL_LIMITS
 #if AXIS_Z_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Z_HOMING_MASK, LINACT2_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Z;
+		return error;
 	}
 #endif
 
 #if AXIS_X_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK))
+	error = mc_home_axis(AXIS_X_HOMING_MASK, LINACT0_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_X;
+		return error;
 	}
 #endif
 
 #if AXIS_Y_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK))
+	error = mc_home_axis(AXIS_Y_HOMING_MASK, LINACT1_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_Y;
+		return error;
 	}
 #endif
 
 #if AXIS_A_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK))
+	error = mc_home_axis(AXIS_A_HOMING_MASK, LINACT3_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return (KINEMATIC_HOMING_ERROR_X | KINEMATIC_HOMING_ERROR_Y | KINEMATIC_HOMING_ERROR_Z);
+		return error;
 	}
 #endif
 
 #if AXIS_B_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK))
+	error = mc_home_axis(AXIS_B_HOMING_MASK, LINACT4_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_B;
+		return error;
 	}
 #endif
 
 #if AXIS_C_HOMING_MASK != 0
-	if (mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK))
+	error = mc_home_axis(AXIS_C_HOMING_MASK, LINACT5_LIMIT_MASK);
+	if (error != STATUS_OK)
 	{
-		return KINEMATIC_HOMING_ERROR_C;
+		return error;
 	}
 #endif
 
@@ -162,11 +169,11 @@ uint8_t kinematics_home(void)
 	block_data.spindle = 0;
 	block_data.dwell = 0;
 	// starts offset and waits to finnish
-	mc_line(target, &block_data);
+	error = mc_line(target, &block_data);
 	itp_sync();
 #endif
 
-	return STATUS_OK;
+	return error;
 }
 
 void kinematics_apply_transform(float *axis)

uCNC/src/interface/grbl_settings.c

@@ -224,7 +224,11 @@ const setting_id_t __rom__ g_settings_id_table[] = {
 #if (KINEMATIC == KINEMATIC_LINEAR_DELTA)
 		{.id = 106, .memptr = &g_settings.delta_arm_length, .type = SETTING_TYPE(0)},
 		{.id = 107, .memptr = &g_settings.delta_armbase_radius, .type = SETTING_TYPE(0)},
+#elif (KINEMATIC == KINEMATIC_DELTA)
 		{.id = 28, .memptr = &g_settings.delta_bicep_homing_angle, .type = SETTING_TYPE(0)},
+		{.id = 106, .memptr = &g_settings.delta_base_radius, .type = SETTING_TYPE(0)},
+		{.id = 107, .memptr = &g_settings.delta_effector_radius, .type = SETTING_TYPE(0)},
+		{.id = 108, .memptr = &g_settings.delta_bicep_length, .type = SETTING_TYPE(0)},
 		{.id = 109, .memptr = &g_settings.delta_forearm_length, .type = SETTING_TYPE(0)},
 #elif (KINEMATIC == KINEMATIC_SCARA)
 		{.id = 106, .memptr = &g_settings.scara_arm_length, .type = SETTING_TYPE(0)},

uCNC/src/modules/system_menu.c

@@ -255,7 +255,6 @@ DECL_MODULE(system_menu)
 	DECL_MENU_VAR(5, s107, STR_EFF_RAD, &g_settings.delta_effector_radius, VAR_TYPE_FLOAT);
 	DECL_MENU_VAR(5, s108, STR_BICEP_LEN, &g_settings.delta_bicep_length, VAR_TYPE_FLOAT);
 	DECL_MENU_VAR(5, s109, STR_FARM_LEN, &g_settings.delta_forearm_length, VAR_TYPE_FLOAT);
-	DECL_MENU_VAR(5, s28, STR_HOME_ANG, &g_settings.delta_bicep_homing_angle, VAR_TYPE_FLOAT);
 #endif
 #endif