diff --git a/include/mcc/mcc_movement_controls.h b/include/mcc/mcc_movement_controls.h
index 996af43..5b2dc34 100644
--- a/include/mcc/mcc_movement_controls.h
+++ b/include/mcc/mcc_movement_controls.h
@@ -49,6 +49,7 @@ enum class MccSimpleMovementControlsErrorCode : int {
     ERROR_OK,
     ERROR_HW_GETSTATE,
     ERROR_HW_SETSTATE,
+    ERROR_HW_ERROR,
     ERROR_PCM_COMP,
     ERROR_CCTE_COMP,
     ERROR_GET_TELEMETRY,
@@ -100,6 +101,8 @@ struct MccSimpleMovementControlsCategory : public std::error_category {
                 return "cannot get hardware state";
             case MccSimpleMovementControlsErrorCode::ERROR_HW_SETSTATE:
                 return "cannot set hardware state";
+            case MccSimpleMovementControlsErrorCode::ERROR_HW_ERROR:
+                return "hardware error occured";
             case MccSimpleMovementControlsErrorCode::ERROR_PCM_COMP:
                 return "PCM computation error";
             case MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP:
@@ -633,6 +636,8 @@ public:
 
             *_stopMoving = false;
 
+            hw_state.movementState = HARDWARE_T::hardware_movement_state_t::HW_MOVE_ADJUSTING;
+
             while (!*_stopMoving) {
                 t_err = telemetry->telemetryData(&tdata);
                 if (t_err) {
@@ -642,6 +647,10 @@ public:
                     return;
                 }
 
+                hw_state.XY.setX(tdata.targetXY.x());
+                hw_state.XY.setY(tdata.targetXY.y());
+                hw_state.XY.setEpoch(ep_t::now());
+
                 log_pos(tdata, dist);
 
                 // logger->logInfo("\tMNT.XY {} {}; MNT.HADEC {} {}", (double)tdata.hwState.XY.x(),
@@ -667,9 +676,45 @@ public:
                         *_lastError = MccSimpleMovementControlsErrorCode::ERROR_TIMEOUT;
                         break;
                     }
+
+                    if (std::get<2>(dist) <= _currentParams.slewToleranceRadius) {
+                        logger->logInfo("target-to-mount distance is lesser than slew acceptable radius - exit!");
+
+                        break;
+                    }
+
+
+                    // start adjusting (precise pointing) the slewing
+                    if (std::get<2>(dist) <= _currentParams.adjustCoordDiff) {
+                        (*cb_sptr)(STATUS_T::MOUNT_STATUS_ADJUSTING);
+                        *_lastError = send_to_hardware(hw_state);
+                        if (_lastError->load()) {
+                            break;
+                        }
+                    }
+
+                    if (tdata.hwState.movementState == HARDWARE_T::hardware_movement_state_t::HW_MOVE_STOPPED) {
+                        // the mount stopped but still to far from target position!!!
+                        if (std::get<2>(dist) > _currentParams.slewToleranceRadius) {
+                            (*cb_sptr)(STATUS_T::MOUNT_STATUS_ADJUSTING);
+
+                            *_lastError = send_to_hardware(hw_state);
+                            if (_lastError->load()) {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                }
+
+                if (tdata.hwState.movementState == HARDWARE_T::hardware_movement_state_t::HW_MOVE_ERROR) {
+                    *_lastError = MccSimpleMovementControlsErrorCode::ERROR_HW_ERROR;
+                    break;
                 }
 
 
+                /*
                 if (slew_and_stop) {  // just wait until the mount stops
                     if (tdata.hwState.movementState == HARDWARE_T::hardware_movement_state_t::HW_MOVE_STOPPED) {
                         // if (std::get<2>(dist) > _currentParams.slewToleranceRadius) {
@@ -696,23 +741,6 @@ public:
 
                     last_hw_time = tdata.hwState.XY.epoch().UTC();
 
-                    // auto ccte_err = tdata.targetPos.toAtSameEpoch(tag_cp);
-                    // if (ccte_err) {
-                    //     *_lastError = mcc_deduced_err(ccte_err, MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP);
-                    // }
-                    // ccte_err = tdata.mountPos.toAtSameEpoch(mnt_cp);
-                    // if (ccte_err) {
-                    //     *_lastError = mcc_deduced_err(ccte_err, MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP);
-                    // }
-
-                    // auto dist = utils::distanceOnSphere(tag_cp.x(), tag_cp.y(), mnt_cp.x(), mnt_cp.y());
-
-                    // logger->logTrace(std::format(
-                    //     "    target-to-mount distance: {} (dx = {}, dy = {})",
-                    //     MccAngleFancyString(std::get<2>(dist)), MccAngleFancyString(std::get<0>(dist)),
-                    //     MccAngleFancyString(std::get<1>(dist))));
-
-
                     // stop slewing and exit from the cycle?
                     if (std::get<2>(dist) <= _currentParams.slewToleranceRadius) {
                         if (tdata.hwState.movementState == HARDWARE_T::hardware_movement_state_t::HW_MOVE_STOPPED ||
@@ -744,6 +772,7 @@ public:
                         break;
                     }
                 }
+                */
 
                 // sleep here
                 std::this_thread::sleep_for(_currentParams.slewingTelemetryInterval);
@@ -776,27 +805,10 @@ public:
                     return;
                 }
 
-                // auto ccte_err = tdata.targetPos.to(tag_cp);
-                // if (ccte_err) {
-                //     *_lastError = mcc_deduced_err(ccte_err, MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP);
-                //     (*cb_sptr)(STATUS_T::MOUNT_STATUS_ERROR);
-
-                //     return;
-                // }
-                // ccte_err = tdata.mountPos.to(mnt_cp);
-                // if (ccte_err) {
-                //     *_lastError = mcc_deduced_err(ccte_err, MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP);
-                //     (*cb_sptr)(STATUS_T::MOUNT_STATUS_ERROR);
-
-                //     return;
-                // }
-
-                // auto dist = utils::distanceOnSphere(tag_cp.x(), tag_cp.y(), mnt_cp.x(), mnt_cp.y());
-
                 log_pos(tdata, dist);
 
-                // logger->logDebug(
-                //     std::format("    target-to-mount distance {}", MccAngleFancyString(std::get<2>(dist))));
+                logger->logInfo(
+                    std::format("    final target-to-mount distance {}", MccAngleFancyString(std::get<2>(dist))));
 
                 if (!slew_and_stop) {  // start tracking
                     _trackingFunc();