...

CMakeLists.txt

@@ -13,7 +13,7 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 # ******* C++ PART OF THE PROJECT *******
 
 set(EXAMPLES OFF CACHE BOOL "" FORCE)
-set(CMAKE_BUILD_TYPE "Release")
+# set(CMAKE_BUILD_TYPE "Release")
 add_subdirectory(LibSidServo)
 set(CMAKE_BUILD_TYPE "Debug")
 

asibfm700/asibfm700_common.h

@@ -13,6 +13,7 @@
 
 #include "mcc_ccte_erfa.h"
 #include "mcc_slewing_model.h"
+#include "mcc_tracking_model.h"
 
 namespace asibfm700
 {
@@ -24,5 +25,6 @@ typedef mcc::MccDefaultPCM<asibfm700MountType> Asibfm700PCM;
 typedef mcc::MccPZoneContainer<mcc::MccTimeDuration> Asibfm700PZoneContainer;
 typedef mcc::utils::MccSpdlogLogger Asibfm700Logger;
 typedef mcc::MccSimpleSlewingModel Asibfm700SlewingModel;
+typedef mcc::MccSimpleTrackingModel Asibfm700TrackingModel;
 
 }  // namespace asibfm700

asibfm700/asibfm700_configfile.h

@@ -183,10 +183,10 @@ static auto Asibfm700MountConfigDefaults = std::make_tuple(
     simple_config_record_t{"pzMinAltitude", mcc::MccAngle(10.0_degs), {"minimal altitude"}},
 
     // HA-axis limit switch minimal value
-    simple_config_record_t{"pzLimitSwitchHAMin", mcc::MccAngle(-170.0_degs), {"HA-axis limit switch minimal value"}},
+    simple_config_record_t{"pzLimitSwitchHAMin", mcc::MccAngle(-270.0_degs), {"HA-axis limit switch minimal value"}},
 
     // HA-axis limit switch maximal value
-    simple_config_record_t{"pzLimitSwitchHAMax", mcc::MccAngle(170.0_degs), {"HA-axis limit switch maximal value"}},
+    simple_config_record_t{"pzLimitSwitchHAMax", mcc::MccAngle(270.0_degs), {"HA-axis limit switch maximal value"}},
 
     // DEC-axis limit switch minimal value
     simple_config_record_t{"pzLimitSwitchDecMin", mcc::MccAngle(-90.0_degs), {"DEC-axis limit switch minimal value"}},

asibfm700/asibfm700_mount.cpp

@@ -19,7 +19,7 @@ Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config, std::shared_p
                  std::make_tuple(this),
                  std::make_tuple(),
                  std::make_tuple(this, Asibfm700Logger{logger}),
-                 std::make_tuple(this),
+                 std::make_tuple(this, Asibfm700Logger{logger}),
                  std::make_tuple(logger, Asibfm700Logger::LOGGER_DEFAULT_FORMAT)),
       // base_gm_class_t(Asibfm700StartState{},
       //                 std::make_tuple(config.servoControllerConfig()),
@@ -263,7 +263,13 @@ Asibfm700Mount::error_t Asibfm700Mount::initMount()
 
     bool ok = isInternalTelemetryDataUpdating();
     if (ok) {
-        logInfo("Start updating telemetry data");
+        logInfo("Start updating telemetry data ...");
+        mcc::MccTelemetryData tdata;
+        auto err = waitForTelemetryData(&tdata, _mountConfig.movingModelParams().telemetryTimeout);
+        if (err) {
+            logError("Cannot update telemetry data (err = {} [{}, {}])!", err.message(), err.value(),
+                     err.category().name());
+        }
     } else {
         auto err = lastUpdateError();
         logError("Cannot update telemetry data (err = {} [{}, {}])!", err.message(), err.value(),

asibfm700/asibfm700_mount.h

@@ -22,14 +22,14 @@ class Asibfm700Mount : public Asibfm700CCTE,
                                                    mcc::MccTelemetry,
                                                    Asibfm700PZoneContainer,
                                                    Asibfm700SlewingModel,
-                                                   mcc::MccSimpleTrackingModel,
+                                                   Asibfm700TrackingModel,
                                                    Asibfm700Logger>
 {
     typedef mcc::MccGenericMount<AsibFM700ServoController,
                                  mcc::MccTelemetry,
                                  Asibfm700PZoneContainer,
                                  Asibfm700SlewingModel,
-                                 mcc::MccSimpleTrackingModel,
+                                 Asibfm700TrackingModel,
                                  Asibfm700Logger>
         gm_class_t;
 

asibfm700/asibfm700_servocontroller.cpp

@@ -115,7 +115,7 @@ AsibFM700ServoController::error_t AsibFM700ServoController::hardwareSetState(har
     // according to"SiTech protocol notes" X is DEC-axis and Y is HA-axis
     coordval_pair_t cvalpair{.X{.val = state.Y, .t = tp}, .Y{.val = state.X, .t = tp}};
     coordpair_t cpair{.X = state.Y, .Y = state.X};
-    // coordpair_t cpair{.X = state.Y, .Y = state.X + mcc::MccAngle(10.0_arcsecs)};
+    // coordpair_t cpair{.X = state.Y, .Y = state.X + mcc::MccAngle(1.0_degs)};
 
     // correctTo is asynchronous function!!!
     //

mcc/mcc_ccte_erfa.h

@@ -506,7 +506,8 @@ public:
                 lst_eo();
                 if (!ret) {
                     // ha = MccAngle(lst - from_pt.X + eo).normalize<MccAngle::NORM_KIND_0_360>();
-                    ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_0_360>();
+                    ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_180_180>();
+                    // ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_0_360>();
                 } else {
                     return ret;
                 }

mcc/mcc_slewing_model.h

@@ -122,7 +122,10 @@ public:
     MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT logger)
         : _stopSlewing(new std::atomic_bool()), _currentParamsMutex(new std::mutex)
     {
-        logger.logDebug("Create MccSimpleSlewingModel class instance");
+        std::ostringstream os;
+        os << std::this_thread::get_id();
+
+        logger.logDebug(std::format("Create MccSimpleSlewingModel class instance (thread: {})", os.str()));
 
         *_stopSlewing = true;
 
@@ -174,7 +177,8 @@ public:
             }
 
             bool in_zone;
-            auto pz_err = controls->inPZone(tdata.target, &in_zone);
+            std::vector<bool> in_zone_vec;
+            auto pz_err = controls->inPZone(tdata.target, &in_zone, &in_zone_vec);
             if (pz_err) {
                 *_stopSlewing = true;
                 return mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
@@ -183,7 +187,14 @@ public:
             if (in_zone) {
                 *_stopSlewing = true;
 
-                logger.logError("target point is in prohibited zone! Entered target coordinates:");
+                size_t i = 0;
+                for (; i < in_zone_vec.size(); ++i) {
+                    if (in_zone_vec[i]) {
+                        break;
+                    }
+                }
+
+                logger.logError("target point is in prohibited zone (zone index: {})! Entered target coordinates:", i);
                 logger.logError(std::format("    RA-APP, DEC-APP, HA, LST: {}, {}, {}, {}",
                                             mcc::MccAngle{tdata.target.RA_APP}.sexagesimal(true),
                                             mcc::MccAngle{tdata.target.DEC_APP}.sexagesimal(),
@@ -193,6 +204,9 @@ public:
                                             mcc::MccAngle{tdata.target.ZD}.sexagesimal(),
                                             mcc::MccAngle{tdata.target.ALT}.sexagesimal()));
 
+                logger.logError(std::format("    hardware X, Y: {}, {}", mcc::MccAngle{tdata.target.X}.sexagesimal(),
+                                            mcc::MccAngle{tdata.target.Y}.sexagesimal()));
+
                 return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE;
             }
 
@@ -310,6 +324,20 @@ public:
 
             std::pair<double, double> distXY;
 
+
+            if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
+                if (tdata.target.pair_kind != MccCoordPairKind::COORDS_KIND_HADEC_APP) {
+                    // here, HA and DEC are changed during slewing process!!
+                    slew_and_stop = false;
+                }
+            } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
+                if (!(tdata.target.pair_kind == MccCoordPairKind::COORDS_KIND_AZALT &&
+                      tdata.target.pair_kind == MccCoordPairKind::COORDS_KIND_AZZD)) {
+                    slew_and_stop = false;
+                }
+            }
+
+
             // main loop (simply monitors the current position taking into account the prohibited zones, as well as the
             // timeout of the entire process)
             while (!*_stopSlewing) {
@@ -442,8 +470,15 @@ public:
                         return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
                     }
 
-                    logger.logDebug("    the 'hardwareSetState' method performed successfully!");
+
+                    {
+                        std::lock_guard lock{*_currentParamsMutex};
+                        logger.logDebug("    the 'hardwareSetState' method performed successfully!");
+                    }
                 }
+
+                // sleep here
+                std::this_thread::sleep_for(_currentParams.slewingTelemetryInterval);
             }
 
             *_stopSlewing = true;

mcc/mcc_telemetry.h

@@ -9,6 +9,7 @@
 #include <condition_variable>
 #include <future>
 #include <mutex>
+#include <stop_token>
 #include <thread>
 
 #include "mcc_defaults.h"
@@ -150,7 +151,7 @@ public:
             MccCelestialPoint hw_cp{.pair_kind = MccCoordPairKind::COORDS_KIND_XY};
             mcc_tp2tp(_data.time_point, hw_cp.time_point);
 
-            if (hw_coords) {  // compute corresponded apparent coordinates
+            if (hw_coords) {  // compute corresponded observed coordinates
                 hw_cp.X = _data.target.X;
                 hw_cp.Y = _data.target.Y;
 
@@ -318,6 +319,7 @@ public:
             MccCelestialPoint pt{.pair_kind = MccCoordPairKind::COORDS_KIND_AZALT, .time_point = _data.time_point};
 
             if constexpr (mccIsEquatorialMount(pcm_t::mountType)) {
+                // NOTE: now it are OBSERVED (NOT APPARENT) RA, HA, DEC!!!
                 _data.RA_APP =
                     MccAngle((double)_data.LST - (double)_data.HA - eo).normalize<MccAngle::NORM_KIND_0_360>();
                 // MccAngle((double)_data.LST - (double)_data.HA + eo).normalize<MccAngle::NORM_KIND_0_360>();
@@ -367,18 +369,32 @@ public:
 
                 ccte_err = controls->refractionCorrection(_data, &_data.refCorr);
                 if (!ccte_err) {
+                    // // compute APPARENT RA, HA and DEC from observer AZ, ZD
+                    // _data.Y += _data.refCorr;  // zenithal distance corrected for the refraction
+
+                    // pt.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP;
+
+                    // ccte_err = controls->transformCoordinates(_data, &pt);
+                    // if (!ccte_err) {
+                    //     _data.HA = pt.X;
+                    //     _data.DEC_APP = pt.Y;
+                    //     _data.RA_APP =
+                    //         MccAngle((double)_data.LST - (double)_data.HA -
+                    //         eo).normalize<MccAngle::NORM_KIND_0_360>();
+
+
                     // restore hardware encoders coordinates
                     _data.X = (double)hw_pos.X;
                     _data.Y = (double)hw_pos.Y;
 
-                    // update target (assuming target ICRS coordinates are already set)
 
-                    // auto ret = _updateTargetFunc(false, stop_token);
+
                     // update target according to its .pair_kind!
                     auto ret = _updateTargetFunc(stop_token);
                     if (ret) {
                         return ret;
                     }
+                    // }
                 }
             }
 
@@ -407,32 +423,35 @@ public:
         _dataUpdatingRequested->clear();
         _dataUpdatingStart->clear();
 
-        _updatingFuture = std::async(
+        _updatingFuture =
-            std::launch::async,
+            std::async(std::launch::async, &MccTelemetry::updateLoop, this, _internalUpdatingStopSource.get_token());
-            [controls, this](std::stop_token stoken) {
-                bool stop_flag = stoken.stop_requested();
-                // controls->logTrace(std::format("stop_requested() = {}", stop_flag));
-                // while (!stoken.stop_requested()) {
-                while (!stop_flag) {
-                    _dataUpdatingRequested->wait(false);
 
-                    stop_flag = stoken.stop_requested();
+        // _updatingFuture = std::async(
-                    if (!stop_flag) {
+        //     std::launch::async,
-                        // if (!stoken.stop_requested()) {
+        //     [controls, this](std::stop_token stoken) {
-                        *_internalUpdating = true;
+        //         bool stop_flag = stoken.stop_requested();
-                        std::lock_guard lock{*_timeoutMutex};
+        //         // controls->logTrace(std::format("stop_requested() = {}", stop_flag));
+        //         // while (!stoken.stop_requested()) {
+        //         while (!stop_flag) {
+        //             _dataUpdatingRequested->wait(false);
 
-                        _dataUpdatingStart->test_and_set();
+        //             stop_flag = stoken.stop_requested();
-                        _dataUpdatingStart->notify_all();
+        //             if (!stop_flag) {
+        //                 // if (!stoken.stop_requested()) {
+        //                 *_internalUpdating = true;
+        //                 std::lock_guard lock{*_timeoutMutex};
 
-                        _lastUpdateError = _updateFunc(stoken);
+        //                 _dataUpdatingStart->test_and_set();
+        //                 _dataUpdatingStart->notify_all();
 
-                        _dataUpdatingStart->clear();
+        //                 _lastUpdateError = _updateFunc(stoken);
-                        _dataUpdatingRequested->clear();
+
-                    }
+        //                 _dataUpdatingStart->clear();
-                }
+        //                 _dataUpdatingRequested->clear();
-            },
+        //             }
-            _internalUpdatingStopSource.get_token());
+        //         }
+        //     },
+        //     _internalUpdatingStopSource.get_token());
     }
 
 
@@ -511,11 +530,14 @@ public:
                     _lastUpdateError = MccTelemetryErrorCode::ERROR_UPDATE_LOOP_WAIT;
                 }
 
-                startInternalTelemetryDataUpdating();
+                _updatingFuture = std::async(std::launch::async, &MccTelemetry::updateLoop, this,
+                                             _internalUpdatingStopSource.get_token());
+
 
                 *_internalUpdating = true;
             } else {
-                startInternalTelemetryDataUpdating();
+                _updatingFuture = std::async(std::launch::async, &MccTelemetry::updateLoop, this,
+                                             _internalUpdatingStopSource.get_token());
 
                 *_internalUpdating = true;
             }
@@ -728,6 +750,31 @@ protected:
     std::unique_ptr<std::timed_mutex> _timeoutMutex{new std::timed_mutex()};
 
     error_t _lastUpdateError{MccTelemetryErrorCode::ERROR_OK};
+
+    void updateLoop(std::stop_token stoken)
+    {
+        bool stop_flag = stoken.stop_requested();
+        // controls->logTrace(std::format("stop_requested() = {}", stop_flag));
+        while (!stoken.stop_requested()) {
+            // while (!stop_flag) {
+            _dataUpdatingRequested->wait(false);
+
+            // stop_flag = stoken.stop_requested();
+            // if (!stop_flag) {
+            if (!stoken.stop_requested()) {
+                *_internalUpdating = true;
+                std::lock_guard lock{*_timeoutMutex};
+
+                _dataUpdatingStart->test_and_set();
+                _dataUpdatingStart->notify_all();
+
+                _lastUpdateError = _updateFunc(stoken);
+
+                _dataUpdatingStart->clear();
+                _dataUpdatingRequested->clear();
+            }
+        }
+    }
 };
 
 

mcc/mcc_tracking_model.h

@@ -22,6 +22,7 @@ enum class MccSimpleTrackingModelErrorCode : int {
     ERROR_DIST_TELEMETRY,
     ERROR_PZONE_CONTAINER_COMP,
     ERROR_NEAR_PZONE,
+    ERROR_IN_PZONE,
     ERROR_ALREADY_TRACK,
     ERROR_ALREADY_STOPPED,
     ERROR_STOPPED
@@ -78,6 +79,8 @@ struct MccSimpleTrackingModelCategory : public std::error_category {
                 return "pzone container computation error";
             case MccSimpleTrackingModelErrorCode::ERROR_NEAR_PZONE:
                 return "near prohibited zone";
+            case MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE:
+                return "in prohibited zone";
             case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_TRACK:
                 return "already tracking";
             case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_STOPPED:
@@ -110,13 +113,18 @@ public:
     typedef MccSimpleMovingModelParams tracking_params_t;
 
 
-    template <mcc_all_controls_c CONTROLS_T>
+    template <mcc_all_controls_c CONTROLS_T, mcc_logger_c LoggerT = MccNullLogger>
-    MccSimpleTrackingModel(CONTROLS_T* controls)
+    MccSimpleTrackingModel(CONTROLS_T* controls, LoggerT logger)
         : _stopTracking(new std::atomic_bool()), _currentParamsMutex(new std::mutex())
     {
+        std::ostringstream os;
+        os << std::this_thread::get_id();
+
+        logger.logDebug(std::format("Create MccSimpleTrackingModel class instance (thread: {})", os.str()));
+
         *_stopTracking = true;
 
-        _trackingFunc = [controls, this]() -> error_t {
+        _trackingFunc = [logger = std::move(logger), controls, this]() mutable -> error_t {
             typename CONTROLS_T::hardware_state_t hw_state;
 
             MccTelemetryData tdata;
@@ -128,17 +136,43 @@ public:
             } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
                 target_in_future_pt.pair_kind = MccCoordPairKind::COORDS_KIND_AZZD;
             } else {
-                static_assert(false, "UNKNOW MOUNT TYPE!");
+                static_assert(false, "UNKNOWN MOUNT TYPE!");
             }
 
             // double dist, dx, dy;
 
+            logger.logInfo("Start tracking:");
+            logger.logInfo("    min time to pzone: {} secs", _currentParams.minTimeToPZone.count());
+
+
             auto t_err = controls->telemetryData(&tdata);
             if (t_err) {
                 *_stopTracking = true;
                 return mcc_deduce_error_code(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY);
             }
 
+            bool in_zone;
+            auto pz_err = controls->inPZone(tdata, &in_zone);
+            if (pz_err) {
+                return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
+            }
+
+            if (in_zone) {
+                logger.logError("mount current coordinates are in prohibited zone:");
+                logger.logError(std::format(
+                    "    RA-APP, DEC-APP, HA, LST: {}, {}, {}, {}", mcc::MccAngle{tdata.RA_APP}.sexagesimal(true),
+                    mcc::MccAngle{tdata.DEC_APP}.sexagesimal(), mcc::MccAngle{tdata.HA}.sexagesimal(true),
+                    mcc::MccAngle{tdata.LST}.sexagesimal(true)));
+                logger.logError(std::format("    AZ, ZD, ALT: {}, {}, {}", mcc::MccAngle{tdata.target.AZ}.sexagesimal(),
+                                            mcc::MccAngle{tdata.ZD}.sexagesimal(),
+                                            mcc::MccAngle{tdata.ALT}.sexagesimal()));
+
+                logger.logError(std::format("    hardware X, Y: {}, {}", mcc::MccAngle{tdata.X}.sexagesimal(),
+                                            mcc::MccAngle{tdata.Y}.sexagesimal()));
+
+                return MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE;
+            }
+
 
             bool no_intersects = false;
 
@@ -168,7 +202,7 @@ public:
                         no_intersects = true;
                     }
                 } else {
-                    static_assert(false, "UNKNOW MOUNT TYPE!");
+                    static_assert(false, "UNKNOWN MOUNT TYPE!");
                 }
 
                 return MccSimpleTrackingModelErrorCode::ERROR_OK;
@@ -183,10 +217,12 @@ public:
                     _currentParams.timeShiftToTargetPoint);
 
                 // point in +time_dist future
-                MccCelestialPoint pt{
+                MccCelestialPoint pt{.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP,
-                    .pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP,
+                                     // .X = MccAngle(dt.count() * std::numbers::pi / 3600.0
-                    .X = MccAngle(dt.count() * std::numbers::pi / 3600.0 / 15.0).normalize<MccAngle::NORM_KIND_0_360>(),
+                                     // / 15.0).normalize<MccAngle::NORM_KIND_0_360>(),
-                    .Y = tdata.DEC_APP};
+                                     .X = MccAngle(dt.count() * std::numbers::pi / 3600.0 / 15.0)
+                                              .normalize<MccAngle::NORM_KIND_180_180>(),
+                                     .Y = tdata.DEC_APP};
                 mcc_tp2tp(tdata.time_point + tp_dt, pt.time_point);
 
                 point->time_point = pt.time_point;
@@ -222,7 +258,7 @@ public:
             };
 
 
-            auto pz_err = update_pzones_ipoint();
+            pz_err = update_pzones_ipoint();
             if (pz_err) {
                 *_stopTracking = true;
                 return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
@@ -243,15 +279,31 @@ public:
                     hw_state.speedX = _currentParams.trackSpeedX;
                     hw_state.speedY = _currentParams.trackSpeedY;
                 }
+
+                logger.logTrace("The updated target point:");
+                if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
+                    logger.logTrace("    HA, DEC: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(true),
+                                    MccAngle(target_in_future_pt.Y).sexagesimal());
+                } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
+                    logger.logTrace("    AZ, ZD: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(),
+                                    MccAngle(target_in_future_pt.Y).sexagesimal());
+                } else {
+                    static_assert(false, "UNKNOWN MOUNT TYPE!");
+                }
             }
 
             // move mount
+            logger.logDebug(std::format("Send to hardware: X = {} degs, Y = {} degs",
+                                        mcc::MccAngle{hw_state.X}.degrees(), mcc::MccAngle{hw_state.Y}.degrees()));
+
             auto hw_err = controls->hardwareSetState(hw_state);
             if (hw_err) {
                 *_stopTracking = true;
                 return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
             }
 
+            logger.logDebug("    the 'hardwareSetState' method performed successfully!");
+
 
             std::chrono::steady_clock::time_point last_corr_tp, last_ipzone_update_tp;
             last_corr_tp = std::chrono::steady_clock::now();
@@ -270,6 +322,26 @@ public:
                     }
                 }
 
+                if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
+                    logger.logTrace(std::format("    current target: HA = {}, DEC = {}",
+                                                mcc::MccAngle(tdata.target.HA).sexagesimal(true),
+                                                mcc::MccAngle(tdata.target.DEC_APP).sexagesimal()));
+                    logger.logTrace(std::format("    current mount:  HA = {}, DEC = {}",
+                                                mcc::MccAngle(tdata.HA).sexagesimal(true),
+                                                mcc::MccAngle(tdata.DEC_APP).sexagesimal()));
+                } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
+                    logger.logTrace(std::format("    target: AZ = {}, ZD = {}",
+                                                mcc::MccAngle(tdata.target.AZ).sexagesimal(),
+                                                mcc::MccAngle(tdata.target.ZD).sexagesimal()));
+                    logger.logTrace(std::format("    mount:  AZ = {}, ZD = {}", mcc::MccAngle(tdata.AZ).sexagesimal(),
+                                                mcc::MccAngle(tdata.ZD).sexagesimal()));
+                }
+
+                logger.logTrace(std::format("    mount:  speedX = {}/s, speedY = {}/s",
+                                            mcc::MccAngleFancyString(tdata.speedX),
+                                            mcc::MccAngleFancyString(tdata.speedY)));
+
+
                 if (*_stopTracking) {
                     break;
                 }
@@ -292,35 +364,56 @@ public:
                     std::lock_guard lock{*_currentParamsMutex};
                     auto now = std::chrono::steady_clock::now();
 
-                    if ((now - last_corr_tp) < _currentParams.trackingCycleInterval) {
+                    if ((now - last_corr_tp) > _currentParams.trackingCycleInterval) {
-                        continue;
+                        // update prohibited zones intersection point
-                    }
+                        if ((now - last_ipzone_update_tp) < _currentParams.updatingPZoneInterval) {
-
+                            pz_err = update_pzones_ipoint();
-                    // update prohibited zones intersection point
+                            if (pz_err) {
-                    if ((now - last_ipzone_update_tp) < _currentParams.updatingPZoneInterval) {
+                                *_stopTracking = true;
-                        pz_err = update_pzones_ipoint();
+                                return mcc_deduce_error_code(
-                        if (pz_err) {
+                                    pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
-                            *_stopTracking = true;
+                            }
-                            return mcc_deduce_error_code(pz_err,
-                                                         MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
                         }
-                    }
 
-                    // compute new target-in-future point
+                        // compute new target-in-future point
-                    auto ccte_err = target_point(&target_in_future_pt);
+                        auto ccte_err = target_point(&target_in_future_pt);
-                    if (ccte_err) {
+                        if (ccte_err) {
-                        *_stopTracking = true;
+                            *_stopTracking = true;
-                        return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE);
+                            return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE);
+                        }
+
+                        logger.logTrace("The updated target point:");
+                        if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
+                            logger.logTrace("    HA, DEC: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(true),
+                                            MccAngle(target_in_future_pt.Y).sexagesimal());
+                        } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
+                            logger.logTrace("    AZ, ZD: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(),
+                                            MccAngle(target_in_future_pt.Y).sexagesimal());
+                        } else {
+                            static_assert(false, "UNKNOWN MOUNT TYPE!");
+                        }
                     }
                 }
 
                 // send corrections
+                logger.logDebug(std::format("Send to hardware: X = {} degs, Y = {} degs",
+                                            mcc::MccAngle{hw_state.X}.degrees(), mcc::MccAngle{hw_state.Y}.degrees()));
+
                 hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_TRACKING;
                 hw_err = controls->hardwareSetState(hw_state);
                 if (hw_err) {
                     *_stopTracking = true;
                     return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
                 }
+
+                logger.logDebug("    the 'hardwareSetState' method performed successfully!");
+
+
+                // sleep here
+                {
+                    std::lock_guard lock{*_currentParamsMutex};
+                    std::this_thread::sleep_for(_currentParams.trackingTelemetryInterval);
+                }
             }
 
             return MccSimpleTrackingModelErrorCode::ERROR_OK;