...

include/mcc/mcc_angle.h

@@ -435,23 +435,36 @@ static T1 operator/(const T1& v1, const T2& v2)
 std::string MccAngleFancyString(std::convertible_to<MccAngle> auto const& ang,
                                 std::format_string<double> val_fmt = "{:.2f}")
 {
+    using ang_t = std::decay_t<decltype(ang)>;
     std::string s;
 
     double abs_ang;
-    if constexpr (std::is_arithmetic_v<std::decay_t<decltype(ang)>>) {
+    if constexpr (std::is_arithmetic_v<ang_t>) {
         abs_ang = std::abs(ang);
     } else {
         abs_ang = std::abs(MccAngle{ang});
     }
 
     if (abs_ang < 1.0_arcmins) {
-        std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.arcsecs());
+        if constexpr (std::derived_from<ang_t, MccAngle>) {
+            std::format_to(std::back_inserter(s), val_fmt, ang.arcsecs());
+        } else {
+            std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.arcsecs());
+        }
         s += " arcsecs";
     } else if (abs_ang < 1.0_degs) {
-        std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.arcmins());
+        if constexpr (std::derived_from<ang_t, MccAngle>) {
+            std::format_to(std::back_inserter(s), val_fmt, ang.arcmins());
+        } else {
+            std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.arcmins());
+        }
         s += " arcmins";
     } else {
-        std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.degrees());
+        if constexpr (std::derived_from<ang_t, MccAngle>) {
+            std::format_to(std::back_inserter(s), val_fmt, ang.degrees());
+        } else {
+            std::format_to(std::back_inserter(s), val_fmt, MccAngle{ang}.degrees());
+        }
         s += " degs";
     }
 

include/mcc/mcc_concepts.h

@@ -834,16 +834,19 @@ struct mcc_telemetry_interface_t {
 };
 
 template <typename T>
-concept mcc_telemetry_c = std::derived_from<T, mcc_telemetry_interface_t<typename T::error_t>> && requires(T t) {
+concept mcc_telemetry_c =
-    // error type
+    std::derived_from<T, mcc_telemetry_interface_t<typename T::error_t>> && requires(T t, const T t_const) {
-    requires mcc_error_c<typename T::error_t>;
+        // error type
+        requires mcc_error_c<typename T::error_t>;
 
-    // telemetry data type definition
+        // telemetry data type definition
-    requires mcc_telemetry_data_c<typename T::telemetry_data_t>;
+        requires mcc_telemetry_data_c<typename T::telemetry_data_t>;
 
-    // get telemetry data
+        // get telemetry data
-    { t.telemetryData(std::declval<typename T::telemetry_data_t*>()) } -> std::same_as<typename T::error_t>;
+        { t.telemetryData(std::declval<typename T::telemetry_data_t*>()) } -> std::same_as<typename T::error_t>;
-};
+
+        { t_const.getPointingTarget() } -> mcc_skypoint_c;
+    };
 
 
 

include/mcc/mcc_coordinate.h

@@ -537,6 +537,78 @@ public:
         return error_t{};
     }
 
+    // 'inner' transformation
+    error_t to(MccCoordPairKind pair_kind)
+    {
+        return to(pair_kind, _epoch);
+    }
+
+    error_t to(MccCoordPairKind pair_kind, mcc_coord_epoch_c auto const& epoch)
+    {
+        // do not use here "mcc_coord_epoch_c::operator==" to avoid
+        // unnecessary computations (astrometrical algorithms mainly use Julian date as input)
+        if (pair_kind == _pairKind && utils::isEqual(epoch.MJD(), _epoch.MJD())) {
+            _epoch = epoch;
+
+            return error_t{};
+        }
+
+        auto tr_func = [&, this]<mcc_coord_pair_c T>(T& cp) {
+            if constexpr (T::pairKind != MccCoordPairKind::COORDS_KIND_RADEC_ICRS) {
+                cp.setEpoch(epoch);
+            }
+
+            auto err = to(cp);
+
+            if (!err) {
+                from(cp);
+            }
+
+            return err;
+        };
+
+        switch (pair_kind) {
+            case MccCoordPairKind::COORDS_KIND_RADEC_ICRS: {
+                MccSkyRADEC_ICRS cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_RADEC_OBS: {
+                MccSkyRADEC_OBS cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_RADEC_APP: {
+                MccSkyRADEC_APP cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_HADEC_OBS: {
+                MccSkyHADEC_OBS cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_HADEC_APP: {
+                MccSkyHADEC_APP cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_AZZD: {
+                MccSkyAZZD cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_AZALT: {
+                MccSkyAZALT cp;
+                return tr_func(cp);
+            } break;
+            case MccCoordPairKind::COORDS_KIND_GENERIC:
+            case MccCoordPairKind::COORDS_KIND_UNKNOWN:
+            case MccCoordPairKind::COORDS_KIND_LONLAT:
+            case MccCoordPairKind::COORDS_KIND_XY: {
+                MccGenXY cp;
+                return tr_func(cp);
+            } break;
+            default:
+                return error_t{};
+        }
+
+        return error_t{};
+    }
 
     error_t refractCorrection(mcc_angle_c auto* dZ) const
     {
@@ -751,6 +823,8 @@ protected:
         double phi = cctEngine.getStateERFA().lat;
         double ra_icrs, dec_icrs, ra, dec, ha, az, zd, alt, lst, eo;
 
+        static_assert(PT::pairKind != MccCoordPairKind::COORDS_KIND_LONLAT, "UNSUPPORTED SKY POINT TRANSFORMATION!");
+        // static_assert(PT::pairKind != MccCoordPairKind::COORDS_KIND_XY, "UNSUPPORTED SKY POINT TRANSFORMATION!");
         static_assert(PT::pairKind != MccCoordPairKind::COORDS_KIND_GENERIC, "UNSUPPORTED SKY POINT TRANSFORMATION!");
         static_assert(PT::pairKind != MccCoordPairKind::COORDS_KIND_UNKNOWN, "UNSUPPORTED SKY POINT TRANSFORMATION!");
 
@@ -786,7 +860,8 @@ protected:
         // 1) convert stored coordinates to ICRS ones
         // 2) convert from the computed ICRS coordinates to required ones
         MccCoordPairKind pkind = _pairKind;
-        if (!utils::isEqual(_epoch.MJD(), cpair.MJD())) {  // convert stored pair to ICRS one (ra_icrs, dec_icrs)
+        if (!utils::isEqual(_epoch.MJD(),
+                            cpair.MJD())) {  // convert stored pair to ICRS one (ra_icrs, dec_icrs)
             if (_pairKind != MccCoordPairKind::COORDS_KIND_RADEC_ICRS) {
                 pkind = MccCoordPairKind::COORDS_KIND_RADEC_ICRS;
 
@@ -955,7 +1030,8 @@ protected:
                     cpair.setY(dec);
                 } else {
                     obj->hadec2azalt(ha, dec, phi, az, alt);
-                    if constexpr (mccIsObsCoordPairKind<PT::pairKind>) {  // RADEC_OBS, HADEC_OBS, AZALT, AZZD
+                    if constexpr (mccIsObsCoordPairKind<PT::pairKind>) {  // RADEC_OBS, HADEC_OBS,
+                                                                          // AZALT, AZZD
                         // correct for refraction: alt += dz_refr
                         double dZ;
                         ccte_err = cctEngine.refractionInverseCorrection(MCC_HALF_PI - alt, &dZ);
@@ -1008,7 +1084,8 @@ protected:
 };
 
 
-/*                          MCC-LIBRARY DEFAULT SKY POINT CLASS IMPLEMENTATION BASED ON THE ERFA LIBRARY */
+/*                          MCC-LIBRARY DEFAULT SKY POINT CLASS IMPLEMENTATION BASED ON THE ERFA LIBRARY
+ */
 
 typedef MccGenericSkyPoint<mcc::ccte::erfa::MccCCTE_ERFA> MccSkyPoint;
 

include/mcc/mcc_deserializer.h

@@ -279,14 +279,18 @@ struct MccDeserializer<VT> : MccDeserializerBase {
     {
         auto pars = params;
 
-        // valid format: X<elem-delim>Y[<elem-delim>TIME-POINT<elem-delim>PAIR-KIND]
+        //         valid format: X<elem-delim>Y[<elem-delim>TIME-POINT<elem-delim>PAIR-KIND]
-        //               X<elem-delim>Y (assumed RADEC_ICRS and J2000.0 epoch)
+        //                       X<elem-delim>Y (assumed RADEC_ICRS and J2000.0 epoch)
+
+        // valid format: X<elem-delim>Y<elem-delim>PAIRKIND<elem-delim>EPOCH
+        //               X<elem-delim>Y<elem-delim>PAIRKIND (assumed epoch is NOW, or J2000.0 if PAIRKIND == RADEC-ICRS)
+        //               X<elem-delim>Y (assumed RADEC-ICRS and J2000.0 epoch)
 
         bool empty;
 
         auto elems = MccDeserializerBase::splitValueIntoElements(input, params, empty);
 
-        if (empty || (elems.size() < 2) || (elems.size() == 3)) {
+        if (empty || (elems.size() < 2)) {
             return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
         }
 
@@ -298,20 +302,30 @@ struct MccDeserializer<VT> : MccDeserializerBase {
 
         typename MccDeserializer<MccAngle>::error_t dsr_err;
 
-        if (elems.size() > 3) {  // full format
+        if (elems.size() > 2) {  // no epoch
             // deserialize pair kind string
-            pair_kind = MccCoordStrToPairKind(elems[3]);
+            pair_kind = MccCoordStrToPairKind(elems[2]);
             if (pair_kind == MccCoordPairKind::COORDS_KIND_UNKNOWN) {
                 return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
             }
 
-            // epoch
+            if (pair_kind != MccCoordPairKind::COORDS_KIND_RADEC_ICRS) {
-            bool ok = epoch.fromCharRange(elems[2]);
+                epoch = MccCelestialCoordEpoch::now();
-            if (!ok) {
-                return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
             }
         }
 
+        if (elems.size() > 3) {  // full format
+            // epoch
+            if (pair_kind != MccCoordPairKind::COORDS_KIND_RADEC_ICRS) {  // ignore epoch if PAIRKIND == RADEC-ICRS
+                bool ok = epoch.fromCharRange(elems[3]);
+                if (!ok) {
+                    return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
+                }
+            }
+        }
+
+
+
         // deserialize X and Y
         if (params.coordpair_format == MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURDEG) {
             pars.angle_format = MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS;
@@ -375,10 +389,9 @@ struct MccDeserializer<MccCoordPairKind> : MccDeserializerBase {
     static constexpr std::string_view deserializerName{"MCC-COORDPAIR-DESERIALIZER"};
 
     template <mcc_serialization_params_c ParamsT = mcc_serialization_params_t>
-    error_t operator ()(
+    error_t operator()(traits::mcc_input_char_range auto const& input,
-        traits::mcc_input_char_range auto const& input,
+                       MccCoordPairKind& value,
-        MccCoordPairKind& value,
+                       ParamsT const& params = mcc_serialization_params_t{})
-        ParamsT const& params = mcc_serialization_params_t{})
     {
         value = MccCoordStrToPairKind(input);
 
@@ -396,10 +409,9 @@ struct MccDeserializer<MccSerializedAngleFormatPrec> : MccDeserializerBase {
     static constexpr std::string_view deserializerName{"MCC-ANGLE-FORMAT-PREC-DESERIALIZER"};
 
     template <mcc_serialization_params_c ParamsT = mcc_serialization_params_t>
-    error_t operator ()(
+    error_t operator()(traits::mcc_input_char_range auto const& input,
-        traits::mcc_input_char_range auto const& input,
+                       MccSerializedAngleFormatPrec& value,
-        MccSerializedAngleFormatPrec& value,
+                       ParamsT const& params = mcc_serialization_params_t{})
-        ParamsT const& params = mcc_serialization_params_t{})
     {
         // valid format: hour_prec[<params.elem_delim>deg_prec<params.elem_delim>decimals]
 
@@ -433,10 +445,9 @@ struct MccDeserializer<MccSerializedCoordPairFormat> : MccDeserializerBase {
     static constexpr std::string_view deserializerName{"MCC-COORDPAIR-FORMAT-DESERIALIZER"};
 
     template <mcc_serialization_params_c ParamsT = mcc_serialization_params_t>
-    error_t operator ()(
+    error_t operator()(traits::mcc_input_char_range auto const& input,
-        traits::mcc_input_char_range auto const& input,
+                       MccSerializedCoordPairFormat& value,
-        MccSerializedCoordPairFormat& value,
+                       ParamsT const& params = mcc_serialization_params_t{})
-        ParamsT const& params = mcc_serialization_params_t{})
     {
         value = MccSerializedCoordPairFormatStrToValue(input);
 

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,27 +676,63 @@ 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;
+                    }
 
 
-                if (slew_and_stop) {  // just wait until the mount stops
+                    // 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) {
-                            // resend new position since target coordinates are changed in time
+                            (*cb_sptr)(STATUS_T::MOUNT_STATUS_ADJUSTING);
-                            hw_state.movementState = HARDWARE_T::hardware_movement_state_t::HW_MOVE_SLEWING;
-                            hw_state.XY.setX(tdata.targetXY.x());
-                            hw_state.XY.setY(tdata.targetXY.y());
-                            hw_state.XY.setEpoch(ep_t::now());
 
                             *_lastError = send_to_hardware(hw_state);
                             if (_lastError->load()) {
                                 break;
                             }
                         } else {
-                            logger->logInfo("mount movement state is STOPPED! Exit from slewing process!");
                             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) {
+                        //     // resend new position since target coordinates are changed in time
+                        //     hw_state.movementState = HARDWARE_T::hardware_movement_state_t::HW_MOVE_SLEWING;
+                        //     hw_state.XY.setX(tdata.targetXY.x());
+                        //     hw_state.XY.setY(tdata.targetXY.y());
+                        //     hw_state.XY.setEpoch(ep_t::now());
+
+                        //     *_lastError = send_to_hardware(hw_state);
+                        //     if (_lastError->load()) {
+                        //         break;
+                        //     }
+                        // } else {
+                        logger->logInfo("mount movement state is STOPPED! Exit from slewing process!");
+                        break;
+                        // }
+                    }
                 } else {
                     if (last_hw_time == tdata.hwState.XY.epoch().UTC()) {
                         logger->logTrace("Same hardware timepoint! Just continue to polling!\n\n\n\n");
@@ -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,28 +805,8 @@ 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))));
-
                 if (!slew_and_stop) {  // start tracking
                     _trackingFunc();
                 } else {
@@ -846,6 +855,8 @@ public:
             logger->logInfo(std::format("    braking acceleration Y: {} degs/s^2 (in config: {} rads/s^2)",
                                         MccAngle(braking_accelY).degrees(), _currentParams.brakingAccelY));
             logger->logInfo(std::format("    min time to prohibited zone: {} seconds", min_time_to_pzone_in_secs));
+            logger->logInfo(
+                std::format("    max target-to-mount distance: {} arcseconds", _currentParams.trackingMaxCoordDiff));
 
 
             _pathFile << "# \n";
@@ -858,6 +869,8 @@ public:
 
             typename TELEMETRY_T::telemetry_data_t tdata;
             typename HARDWARE_T::hardware_state_t hw_state;
+            std::tuple<double, double, double> dist;
+
 
             auto t_err = telemetry->telemetryData(&tdata);
             if (t_err) {
@@ -869,6 +882,31 @@ public:
                 return;
             }
 
+            log_pos(tdata, dist);
+
+            {
+                std::lock_guard lock{*_currentParamsMutex};
+                if (_currentParams.trackingMaxCoordDiff < std::get<2>(dist)) {
+                    logger->logInfo(
+                        std::format("The target-to-mount distance {} is greater than allowed one ({})! Track current "
+                                    "mount position!",
+                                    MccAngleFancyString(std::get<2>(dist)),
+                                    MccAngleFancyString(_currentParams.trackingMaxCoordDiff)));
+
+                    telemetry->setPointingTarget(tdata.mountPos);
+                }
+            }
+
+            t_err = telemetry->telemetryData(&tdata);
+            if (t_err) {
+                *_lastError = mcc_deduced_err(t_err, MccSimpleMovementControlsErrorCode::ERROR_GET_TELEMETRY);
+                (*cb_sptr)(STATUS_T::MOUNT_STATUS_ERROR);
+
+                _pathFile.save();
+
+                return;
+            }
+
 
             *_lastError = check_pzones(tdata, min_time_to_pzone_in_secs, braking_accelX, braking_accelY);
             if (_lastError->load()) {
@@ -883,8 +921,6 @@ public:
 
             mcc_deduced_coord_pair_t<HARDWARE_T::hwMountType> tag_cp, mnt_cp;
 
-            std::tuple<double, double, double> dist;
-
             *_stopMoving = false;
 
             while (!_stopMoving->load()) {
@@ -916,20 +952,6 @@ public:
 
                 last_hw_time = tdata.hwState.XY.epoch().UTC();
 
-                // auto ccte_err = tdata.targetPos.to(tag_cp);
-                // if (ccte_err) {
-                //     *_lastError = mcc_deduced_err(ccte_err, MccSimpleMovementControlsErrorCode::ERROR_CCTE_COMP);
-                // }
-                // ccte_err = tdata.mountPos.to(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))));
 
                 // resend new position since target coordinates are changed in time
                 hw_state.movementState = HARDWARE_T::hardware_movement_state_t::HW_MOVE_TRACKING;

include/mcc/mcc_netserver.h

@@ -1111,7 +1111,7 @@ protected:
             impl::MccCoordPairKind pair_kind = impl::MccCoordPairKind::COORDS_KIND_UNKNOWN;
             impl::MccSkyPoint sp;
 
-            if (input_msg.paramSize()) {  // ccordinate pair kind is given
+            if (input_msg.paramSize()) {  // cordinate pair kind is given
                 auto vp = input_msg.template paramValue<impl::MccCoordPairKind>(0);
                 if (vp) {  // coordinate pair kind is given
                     pair_kind = vp.value();
@@ -1128,6 +1128,10 @@ protected:
                 }
             }
 
+        } else if (input_msg.withKey(MCC_COMMPROTO_KEYWORD_ENTEREDTAG_STR)) {
+            output_msg.construct(MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_ENTEREDTAG_STR,
+                                 _coordFormat, _coordPrec, mount_ptr->getPointingTarget());
+
         } else if (input_msg.withKey(MCC_COMMPROTO_KEYWORD_TELEMETRY_STR)) {
             typename MountT::telemetry_data_t tdata;
 
@@ -1240,7 +1244,7 @@ protected:
             case impl::MccCoordPairKind::COORDS_KIND_XY:         // interpretated as encoder coordinates
             case impl::MccCoordPairKind::COORDS_KIND_GENERIC: {  // interpretated as encoder coordinates
                 if (target) {
-                    // WARNING: STILL NOT IMPLEMENTED!!!
+                    sp.from(tdata.targetXY);
                 } else {
                     sp.from(tdata.hwState.XY);
                 }

include/mcc/mcc_netserver_proto.h

@@ -146,6 +146,10 @@ static constexpr std::string_view MCC_COMMPROTO_KEYWORD_TARGET_STR = "TARGET";
 static constexpr std::string_view MCC_COMMPROTO_KEYWORD_MOUNT_STR = "MOUNT";
 
 
+// get entered target coordinates:
+static constexpr std::string_view MCC_COMMPROTO_KEYWORD_ENTEREDTAG_STR = "ENTEREDTAG";
+
+
 static constexpr std::string_view MCC_COMMPROTO_KEYWORD_TELEMETRY_STR = "TELEMETRY";
 
 // init mount
@@ -173,18 +177,18 @@ static constexpr std::string_view MCC_COMMPROTO_KEYWORD_TRACK_STR = "TRACK";
 static constexpr std::string_view MCC_COMMPROTO_KEYWORD_STATUS_STR = "STATUS";
 
 // valid keywords
-static constexpr std::array MCC_COMMPROTO_VALID_KEYS = {
+// static constexpr std::array MCC_COMMPROTO_VALID_KEYS = {
-    MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR, MCC_COMMPROTO_KEYWORD_COORDFMT_STR,
+//     MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR, MCC_COMMPROTO_KEYWORD_COORDFMT_STR,
-    MCC_COMMPROTO_KEYWORD_COORDPREC_STR,  MCC_COMMPROTO_KEYWORD_TARGET_STR,       MCC_COMMPROTO_KEYWORD_MOUNT_STR,
+//     MCC_COMMPROTO_KEYWORD_COORDPREC_STR,  MCC_COMMPROTO_KEYWORD_TARGET_STR,       MCC_COMMPROTO_KEYWORD_MOUNT_STR,
-    MCC_COMMPROTO_KEYWORD_TELEMETRY_STR,  MCC_COMMPROTO_KEYWORD_INIT_STR,         MCC_COMMPROTO_KEYWORD_STOP_STR,
+//     MCC_COMMPROTO_KEYWORD_ENTEREDTAG_STR, MCC_COMMPROTO_KEYWORD_TELEMETRY_STR,    MCC_COMMPROTO_KEYWORD_INIT_STR,
-    MCC_COMMPROTO_KEYWORD_SLEW_STR,       MCC_COMMPROTO_KEYWORD_MOVE_STR,         MCC_COMMPROTO_KEYWORD_TRACK_STR,
+//     MCC_COMMPROTO_KEYWORD_STOP_STR,       MCC_COMMPROTO_KEYWORD_SLEW_STR,         MCC_COMMPROTO_KEYWORD_MOVE_STR,
-    MCC_COMMPROTO_KEYWORD_STATUS_STR};
+//     MCC_COMMPROTO_KEYWORD_TRACK_STR,      MCC_COMMPROTO_KEYWORD_STATUS_STR};
 
 
-// hashes of valid keywords
+// // hashes of valid keywords
-static constexpr std::array MCC_COMMPROTO_VALID_KEYS_HASH = []<size_t... Is>(std::index_sequence<Is...>) {
+// static constexpr std::array MCC_COMMPROTO_VALID_KEYS_HASH = []<size_t... Is>(std::index_sequence<Is...>) {
-    return std::array{mcc::utils::FNV1aHash(MCC_COMMPROTO_VALID_KEYS[Is])...};
+//     return std::array{mcc::utils::FNV1aHash(MCC_COMMPROTO_VALID_KEYS[Is])...};
-}(std::make_index_sequence<MCC_COMMPROTO_VALID_KEYS.size()>());
+// }(std::make_index_sequence<MCC_COMMPROTO_VALID_KEYS.size()>());
 
 
 
@@ -213,10 +217,10 @@ struct MccNetMessageValidKeywords {
         MCC_COMMPROTO_KEYWORD_SERVER_ACK_STR, MCC_COMMPROTO_KEYWORD_SERVER_ERROR_STR,
         MCC_COMMPROTO_KEYWORD_COORDFMT_STR,   MCC_COMMPROTO_KEYWORD_COORDPREC_STR,
         MCC_COMMPROTO_KEYWORD_TARGET_STR,     MCC_COMMPROTO_KEYWORD_MOUNT_STR,
-        MCC_COMMPROTO_KEYWORD_TELEMETRY_STR,  MCC_COMMPROTO_KEYWORD_INIT_STR,
+        MCC_COMMPROTO_KEYWORD_ENTEREDTAG_STR, MCC_COMMPROTO_KEYWORD_TELEMETRY_STR,
-        MCC_COMMPROTO_KEYWORD_STOP_STR,       MCC_COMMPROTO_KEYWORD_SLEW_STR,
+        MCC_COMMPROTO_KEYWORD_INIT_STR,       MCC_COMMPROTO_KEYWORD_STOP_STR,
-        MCC_COMMPROTO_KEYWORD_MOVE_STR,       MCC_COMMPROTO_KEYWORD_TRACK_STR,
+        MCC_COMMPROTO_KEYWORD_SLEW_STR,       MCC_COMMPROTO_KEYWORD_MOVE_STR,
-        MCC_COMMPROTO_KEYWORD_STATUS_STR};
+        MCC_COMMPROTO_KEYWORD_TRACK_STR,      MCC_COMMPROTO_KEYWORD_STATUS_STR};
 
 
     // hashes of valid keywords

include/mcc/mcc_serializer.h

@@ -115,8 +115,10 @@ protected:
                                   PAIRKIND == MccCoordPairKind::COORDS_KIND_XY ||
                                   PAIRKIND == MccCoordPairKind::COORDS_KIND_GENERIC) {  // azimuth is in degrees
                         pars.angle_format = MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_DEGS;
+                        pars.norm_sxgm = true;
                     } else {  // RA or HA
                         pars.angle_format = MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS;
+                        pars.norm_sxgm = true;
                     }
                 } else {
                     // !!!!!!!!!!!!!!!!!!
@@ -348,10 +350,10 @@ struct MccSerializer<VT> : MccSerializerBase {
                        VT const& value,
                        ParamsT const& params = mcc_serialization_params_t{})
     {
+        // format: X<elem-delim>Y<elem-delim>PAIRKIND<elem-delim>EPOCH
+
         auto pars = params;
 
-        // pars.norm_sxgm = true;
-        // pars.coordpair_format = MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURDEG;
 
         // X-coordinate
         MccSerializerBase::angleFormatFromCoordPairType<VT::pairKind, MccSerializerBase::CO_LON>(pars);
@@ -363,7 +365,7 @@ struct MccSerializer<VT> : MccSerializerBase {
 
         MccSerializerBase::addElemDelimiter(output, params);
 
-        pars.norm_sxgm = false;  // do not normalize co-latitude angle
+        // pars.norm_sxgm = false;  // do not normalize co-latitude angle
 
         // Y-coordinate
         MccSerializerBase::angleFormatFromCoordPairType<VT::pairKind, MccSerializerBase::CO_LAT>(pars);
@@ -375,6 +377,14 @@ struct MccSerializer<VT> : MccSerializerBase {
 
         MccSerializerBase::addElemDelimiter(output, params);
 
+        // pair kind
+        auto pk_err = MccSerializer<std::string_view>{}(output, MccCoordPairKindToStr(VT::pairKind), params);
+        if (pk_err) {
+            return mcc_deduced_err(pk_err, MccSerializerErrorCode::ERROR_UNDERLYING_SERIALIZER);
+        }
+
+        MccSerializerBase::addElemDelimiter(output, params);
+
         // epoch
         auto ep = value.epoch();
         auto ep_err = MccSerializer<decltype(ep)>{}(output, ep, params);
@@ -383,14 +393,6 @@ struct MccSerializer<VT> : MccSerializerBase {
         }
 
 
-        MccSerializerBase::addElemDelimiter(output, params);
-
-        // pair kind
-        auto pk_err = MccSerializer<std::string_view>{}(output, MccCoordPairKindToStr(VT::pairKind), params);
-        if (pk_err) {
-            return mcc_deduced_err(pk_err, MccSerializerErrorCode::ERROR_UNDERLYING_SERIALIZER);
-        }
-
         return MccSerializerErrorCode::ERROR_OK;
     }
 };
@@ -406,7 +408,7 @@ struct MccSerializer<VT> : MccSerializerBase {
                        ParamsT const& params = mcc_serialization_params_t{})
     {
         auto serialize_cpair = [&]<typename T>(T& cp) -> error_t {
-            auto ccte_err = value.to(cp);
+            auto ccte_err = value.toAtSameEpoch(cp);
             if (ccte_err) {
                 return mcc_deduced_err(ccte_err, MccSerializerErrorCode::ERROR_COORD_TRANSFORM);
             }

include/mcc/mcc_telemetry.h

@@ -324,6 +324,12 @@ public:
     }
 
 
+    auto getPointingTarget() const
+    {
+        return _enteredTargetPos;
+    }
+
+
     error_t getPointingTarget(mcc_skypoint_c auto* sp)
     {
         sp = _enteredTargetPos;