...

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_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

@@ -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_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_slewing_model.h

@@ -174,7 +174,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 +184,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 +201,9 @@ public:
                                             mcc::MccAngle{tdata.target.ZD}.sexagesimal(),
                                             mcc::MccAngle{tdata.target.ALT}.sexagesimal()));
 
+                logger.logError(std::format("    X-enc, Y-enc: {}, {}", mcc::MccAngle{tdata.target.X}.sexagesimal(),
+                                            mcc::MccAngle{tdata.target.Y}.sexagesimal()));
+
                 return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE;
             }
 
@@ -310,6 +321,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 +467,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();
+            }
+        }
+    }
 };