fix: improve the state engine and clean boolean by adding a substep.

---
 Key Changes:

   1. State Machine Asynchronicity:
       * Added TMC_ControlState::NONE to the enum to represent an idle "post-power" state.
       * Introduced the postPowerState class member to store pending calibration tasks when power is lost.
       * Refactored TMC_ControlState::waitPower logic into a dedicated private method handleStateWaitPower(). This method now checks for a postPowerState and automatically resumes the pending task
         once power is stable.

   2. Removal of Blocking Loops:
       * Removed all while(!hasPower()) { Delay(100); } blocking calls within the Run() state machine.
       * In states like Pidautotune, CoggingCalibration, and SlewRateCalibration, the driver now detects missing power, sets the postPowerState, and transitions to waitPower asynchronously.

   3. Code Architecture & Readability:
       * Extracted the logic for complex states (waitPower, Running, FullCalibration) into private methods: handleStateWaitPower(), handleStateRunning(), and handleStateFullCalibration().
       * Reduced the size of the Run() loop, making the overall state transitions much clearer.
       * Simplified the FullCalibration workflow to be non-blocking regarding power availability.

   4. Stability:
       * Maintained the allowStateChange guard mechanism to ensure atomic operations (like actual SPI register tuning) are not interrupted by external state requests.
       * Ensured all code comments and newly added logic are in English.

Author: manoukianv

Firmware/FFBoard/UserExtensions/Inc/TMC4671.h

@@ -66,7 +66,7 @@ enum class TMC_ControlState : uint32_t {uninitialized,waitPower,Shutdown,Running
 #ifdef COGGING_TABLE_FLASH_START_ADDRESS
 	,CoggingCalibration
 #endif
-	,SlewRateCalibration
+	,SlewRateCalibration, NONE
 };
 
 enum class TMC_PwmMode : uint8_t {off = 0,HSlow_LShigh = 1, HShigh_LSlow = 2, res2 = 3, res3 = 4, PWM_LS = 5, PWM_HS = 6, PWM_FOC = 7};
@@ -680,6 +680,7 @@ friend class TMCDebugBridge;
 	TMC_ControlState state = TMC_ControlState::uninitialized;
 	TMC_ControlState laststate = TMC_ControlState::uninitialized;
 	TMC_ControlState requestedState = TMC_ControlState::Shutdown;
+	TMC_ControlState postPowerState = TMC_ControlState::NONE;
 	MotionMode curMotionMode = MotionMode::stop;
 	MotionMode lastMotionMode = MotionMode::stop;
 	MotionMode nextMotionMode = MotionMode::stop;
@@ -744,6 +745,10 @@ friend class TMCDebugBridge;
 //	void ABN_init();
 //	void AENC_init();
 
+	void handleStateWaitPower();
+	void handleStateRunning();
+	void handleStateFullCalibration();
+
 	void encoderInit();
 	void errorCallback(const Error &error, bool cleared);
 	bool pidAutoTune();

Firmware/FFBoard/UserExtensions/Src/TMC4671.cpp

@@ -509,69 +509,21 @@ void TMC4671::Run(){
 			break;
 
 		case TMC_ControlState::waitPower:
-		{
-			allowStateChange = false;
-			pulseClipLed(); // blink led
-			// if powered check ADCs and go to encoder calibration
-			if(!hasPower() || emergency){
-				this->powerCheckCounter = 0;
-				Delay(250);
-				break;
-			}
-			if(++this->powerCheckCounter > 5 && !powerInitialized){
-				initializeWithPower();
-			}
-			if(powerInitialized){
-				allowStateChange = true;
-			}
-			Delay(100);
+			handleStateWaitPower();
 			break;
-		}
 
 		case TMC_ControlState::FullCalibration:
-		{
-			fullCalibrationInProgress = true;
-			/*
-			 * Wait for power (OK)
-			 * Calibrate ADC offsets (OK)
-			 * Measure motor response
-			 * depending on encoder do encoder parameter estimation
-			 * align and store phiE for single phase AENC or indexed ABN enc
-			 *
-			 * If at any point external movement is detected abort
-			 */
-			 // Wait for Power
-			while(!hasPower()){
-				Delay(100);
-			}
-			curFilters.flux.params.enable = false;
-			setBiquadFlux(curFilters.flux);
-			// Calibrate ADC
-			enablePin.set();
-			setPwm(TMC_PwmMode::PWM_FOC); // enable foc to calibrate adc
-			Delay(50);
-			if(calibrateAdcOffset(500)){
-				saveAdcParams();
-			}else{
-				calibFailCb();
-				break;
-			}
-
-			// Encoder
-			calibrateEncoder();
-			setEncoderType(conf.motconf.enctype);
-			recalibrationRequired = false;
-			curFilters.flux.params.enable = true;
-			setBiquadFlux(curFilters.flux);
+			handleStateFullCalibration();
 			break;
-		}
+
 		case TMC_ControlState::Pidautotune:
 			{
-				allowStateChange = false;
-				 // Wait for Power
-				while(!hasPower()){
-					Delay(100);
+				if(!hasPower()){
+					this->postPowerState = TMC_ControlState::Pidautotune;
+					changeState(TMC_ControlState::waitPower);
+					break;
 				}
+				allowStateChange = false;
 				pidAutoTune();
 				allowStateChange = true;
 				changeState(laststate,false);
@@ -581,11 +533,12 @@ void TMC4671::Run(){
 #ifdef COGGING_TABLE_FLASH_START_ADDRESS
 		case TMC_ControlState::CoggingCalibration:
 			{
-				allowStateChange = false;
-				 // Wait for Power
-				while(!hasPower()){
-					Delay(100);
+				if(!hasPower()){
+					this->postPowerState = TMC_ControlState::CoggingCalibration;
+					changeState(TMC_ControlState::waitPower);
+					break;
 				}
+				allowStateChange = false;
 				calibrateCogging();
 				allowStateChange = true;
 				changeState(laststate,false);
@@ -599,57 +552,8 @@ void TMC4671::Run(){
 			break;
 
 		case TMC_ControlState::Running:
-		{
-#ifdef COGGING_TABLE_FLASH_START_ADDRESS
-			// Update anti-cogging compensation
-			if(cogging_enabled){
-				uint16_t pos_mechanical = (uint16_t)getPos(); // Mechanical position 0-65535
-				const uint16_t current_index = (uint32_t)pos_mechanical * CALIB_MAP_SIZE / 65536;
-
-				if(current_index < CALIB_MAP_SIZE){
-					// Apply compensation torque equal to the measured cogging torque
-					const int16_t compensation_torque = -data_cogging[current_index];
-					// Write to PID_TORQUE_OFFSET (register 0x65)
-					updateReg(0x65, compensation_torque, 0xffff, 16);
-				} else {
-					// If the index is out of bounds, ensure the offset is zero
-					updateReg(0x65, 0, 0xffff, 16);
-				}
-			}
-#endif
-
-			// Check status, Temps, Everything alright?
-			uint32_t tick = HAL_GetTick();
-			if(tick - lastStatTime > 2000){ // Every 2s
-				lastStatTime = tick;
-				statusCheck();
-				// Get enable input. If tmc does not reply the result will read 0 or 0xffffffff (not possible normally)
-				uint32_t pins = readReg(0x76);
-				bool tmc_en = ((pins >> 15) & 0x01) && pins != 0xffffffff;
-				if(!tmc_en && motorEnabledRequested){ // Hardware emergency.
-					this->estopTriggered = true;
-					this->emergencyStop(false);
-					ErrorHandler::addError(estopError);
-					//changeState(TMC_ControlState::HardError);
-				}
-
-				// Temperature sense
-				if(conf.hwconf.thermistorSettings.temperatureEnabled){
-					float temp = getTemp();
-					if(temp > conf.hwconf.thermistorSettings.temp_limit){
-						changeState(TMC_ControlState::OverTemp);
-						pulseErrLed();
-					}
-				}
-
-			}
-#ifdef COGGING_TABLE_FLASH_START_ADDRESS
-			Delay(1); // Update anticogging at ~1khz
-#else
-			Delay(200);
-#endif
-		}
-		break;
+			handleStateRunning();
+			break;
 
 		case TMC_ControlState::Shutdown:
 			Delay(100);
@@ -711,11 +615,12 @@ void TMC4671::Run(){
 
 		case TMC_ControlState::SlewRateCalibration:
 			{
-				allowStateChange = false;
-				 // Wait for Power
-				while(!hasPower()){
-					Delay(100);
+				if(!hasPower()){
+					this->postPowerState = TMC_ControlState::SlewRateCalibration;
+					changeState(TMC_ControlState::waitPower);
+					break;
 				}
+				allowStateChange = false;
 				measureMaxSlewRate();
 				allowStateChange = true;
 				if(fullCalibrationInProgress){
@@ -757,7 +662,6 @@ void TMC4671::Run(){
 		}
 	} // End while
 }
-
 void TMC4671::calibrateEncoder(){
 	if(conf.motconf.enctype == EncoderType_TMC::abn) {
 		estimateABNparams();
@@ -3487,4 +3391,111 @@ void TMC4671::measureMaxSlewRate(){
 	setMotionMode(lastmode,true);
 }
 
+void TMC4671::handleStateWaitPower() {
+	allowStateChange = false;
+	pulseClipLed(); // blink led
+
+	if (!hasPower() || emergency) {
+		this->powerCheckCounter = 0;
+		Delay(250);
+		return;
+	}
+
+	if (++this->powerCheckCounter > 5) {
+		if (!powerInitialized) {
+			initializeWithPower();
+		}
+		allowStateChange = true;
+
+		// If a calibration was pending power, go there now
+		if (this->postPowerState != TMC_ControlState::NONE) {
+			changeState(this->postPowerState);
+			this->postPowerState = TMC_ControlState::NONE;
+		} else if (encoderAligned) {
+			// Normal flow if encoder is already aligned
+			changeState(requestedState);
+		}
+	}
+	Delay(100);
+}
+
+void TMC4671::handleStateRunning() {
+#ifdef COGGING_TABLE_FLASH_START_ADDRESS
+	// Update anti-cogging compensation
+	if (cogging_enabled) {
+		uint16_t pos_mechanical = (uint16_t)getPos(); // Mechanical position 0-65535
+		const uint16_t current_index = (uint32_t)pos_mechanical * CALIB_MAP_SIZE / 65536;
+
+		if (current_index < CALIB_MAP_SIZE) {
+			// Apply compensation torque equal to the measured cogging torque
+			const int16_t compensation_torque = -data_cogging[current_index];
+			// Write to PID_TORQUE_OFFSET (register 0x65)
+			updateReg(0x65, compensation_torque, 0xffff, 16);
+		} else {
+			// If the index is out of bounds, ensure the offset is zero
+			updateReg(0x65, 0, 0xffff, 16);
+		}
+	}
+#endif
+
+	// Check status, Temps, Everything alright?
+	uint32_t tick = HAL_GetTick();
+	if (tick - lastStatTime > 2000) { // Every 2s
+		lastStatTime = tick;
+		statusCheck();
+		// Get enable input. If tmc does not reply the result will read 0 or 0xffffffff (not possible normally)
+		uint32_t pins = readReg(0x76);
+		bool tmc_en = ((pins >> 15) & 0x01) && pins != 0xffffffff;
+		if (!tmc_en && motorEnabledRequested) { // Hardware emergency.
+			this->estopTriggered = true;
+			this->emergencyStop(false);
+			ErrorHandler::addError(estopError);
+		}
+
+		// Temperature sense
+		if (conf.hwconf.thermistorSettings.temperatureEnabled) {
+			float temp = getTemp();
+			if (temp > conf.hwconf.thermistorSettings.temp_limit) {
+				changeState(TMC_ControlState::OverTemp);
+				pulseErrLed();
+			}
+		}
+	}
+#ifdef COGGING_TABLE_FLASH_START_ADDRESS
+	Delay(1); // Update anticogging at ~1khz
+#else
+	Delay(200);
+#endif
+}
+
+void TMC4671::handleStateFullCalibration() {
+	if (!hasPower()) {
+		this->postPowerState = TMC_ControlState::FullCalibration;
+		changeState(TMC_ControlState::waitPower);
+		return;
+	}
+
+	fullCalibrationInProgress = true;
+	curFilters.flux.params.enable = false;
+	setBiquadFlux(curFilters.flux);
+	
+	// Calibrate ADC
+	enablePin.set();
+	setPwm(TMC_PwmMode::PWM_FOC); // enable foc to calibrate adc
+	Delay(50);
+	if (calibrateAdcOffset(500)) {
+		saveAdcParams();
+	} else {
+		calibFailCb();
+		return;
+	}
+
+	// Encoder
+	calibrateEncoder();
+	setEncoderType(conf.motconf.enctype);
+	recalibrationRequired = false;
+	curFilters.flux.params.enable = true;
+	setBiquadFlux(curFilters.flux);
+}
+
 #endif