Disable stepper driver during initialization and ensure it only activates during motion

Author: andre-stefanov

app/src/Focuser.cpp

@@ -25,7 +25,9 @@ namespace
 Focuser::Focuser(FocuserStepper &stepper, PositionStore *store, const char *firmware_version)
 	: m_firmware_version(firmware_version), m_stepper(stepper), m_store(store)
 {
-	(void)set_stepper_driver_enabled(true);
+	/* Do not touch hardware here; start with the stepper driver disabled.
+	 * The driver is enabled only for the duration of motion.
+	 */
 }
 
 int Focuser::initialise()
@@ -37,7 +39,8 @@ int Focuser::initialise()
 		return -ENODEV;
 	}
 
-	int ret = set_stepper_driver_enabled(true);
+	/* Ensure the stepper driver starts disabled; it will be enabled during motion only. */
+	int ret = set_stepper_driver_enabled(false);
 	if (ret != 0)
 	{
 		return ret;
@@ -284,20 +287,23 @@ void Focuser::move_to(uint16_t target)
 		interval_ns = m_state.step_interval_ns;
 	}
 
-	if (set_stepper_driver_enabled(true) != 0)
+	const bool enabled_for_move = (set_stepper_driver_enabled(true) == 0);
+	if (!enabled_for_move)
 	{
 		return;
 	}
 
 	if (apply_step_interval(interval_ns) != 0)
 	{
+		(void)set_stepper_driver_enabled(false);
 		return;
 	}
 
 	int ret = m_stepper.move_to(static_cast<int32_t>(target));
 	if (ret != 0)
 	{
 		LOG_ERR("Failed to start move to 0x%04x (%d)", target, ret);
+		(void)set_stepper_driver_enabled(false);
 		return;
 	}
 

tests/app/focuser/src/main.cpp

@@ -132,8 +132,10 @@ ZTEST(focuser_app, test_initialise_requires_ready_stepper)
 		"should not set reference position on failure");
 	zassert_equal(fake_stepper_set_microstep_interval_fake.call_count, 0U,
 		"should not update step interval on failure");
-	zassert_equal(fake_stepper_drv_enable_fake.call_count, 1U,
-		"only constructor enable should run");
+	zassert_equal(fake_stepper_drv_enable_fake.call_count, 0U,
+		"driver should not be enabled during startup");
+	zassert_equal(fake_stepper_drv_disable_fake.call_count, 0U,
+		"driver should not be touched when hardware is not ready");
 }
 
 ZTEST(focuser_app, test_initialise_configures_stepper_when_ready)
@@ -153,10 +155,10 @@ ZTEST(focuser_app, test_initialise_configures_stepper_when_ready)
 		"step interval should be applied once");
 	zassert_equal(fake_stepper_set_microstep_interval_fake.arg1_val, 500000ULL,
 		"default speed uses 500us interval");
-	zassert_equal(fake_stepper_drv_enable_fake.call_count, 2U,
-		"constructor plus initialise enable calls expected");
-	zassert_equal(fake_stepper_drv_disable_fake.call_count, 0U,
-		"driver should remain enabled after init");
+	zassert_equal(fake_stepper_drv_enable_fake.call_count, 0U,
+		"driver should not be enabled during init");
+	zassert_equal(fake_stepper_drv_disable_fake.call_count, 1U,
+		"initialise should ensure the driver starts disabled");
 }
 
 ZTEST(focuser_app, test_initialise_restores_position_from_store)
@@ -260,14 +262,16 @@ ZTEST(focuser_app, test_initialise_ignores_ealready_from_driver)
 	ZephyrFocuserStepper stepper(k_stepper_controller, k_stepper_driver);
 	Focuser focuser(stepper, nullptr, kFirmwareVersion);
 
-	int enable_results[] = {-EALREADY, -EALREADY};
-	SET_RETURN_SEQ(fake_stepper_drv_enable, enable_results, 2);
+	int disable_results[] = {-EALREADY};
+	SET_RETURN_SEQ(fake_stepper_drv_disable, disable_results, 1);
 
 	const int ret = focuser.initialise();
 
 	zassert_equal(ret, 0, "-EALREADY responses should not fail init");
-	zassert_equal(fake_stepper_drv_enable_fake.call_count, 2U,
-		"two enable attempts should have occurred");
+	zassert_equal(fake_stepper_drv_disable_fake.call_count, 1U,
+		"initialise should attempt to disable the driver once");
+	zassert_equal(fake_stepper_drv_enable_fake.call_count, 0U,
+		"initialise should not enable the driver");
 }
 
 ZTEST(focuser_app, test_eeprom_position_store_roundtrip)