From e18066e4a68975dfd6dddee073fc26e020f15cff Mon Sep 17 00:00:00 2001 From: "Timur A. Fatkhullin" Date: Sun, 16 Nov 2025 00:58:56 +0300 Subject: [PATCH] add logging in MccSimpleSlewingModel class --- CMakeLists.txt | 4 +- asibfm700/asibfm700_common.h | 3 +- asibfm700/asibfm700_configfile.h | 4 +- asibfm700/asibfm700_mount.cpp | 4 +- asibfm700/asibfm700_mount.h | 19 ++++-- mcc/mcc_generic_mount.h | 4 +- mcc/mcc_slewing_model.h | 114 ++++++++++++++++++++++++------- 7 files changed, 112 insertions(+), 40 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bbe6e9c..a46afd6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,9 +13,9 @@ 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") +set(CMAKE_BUILD_TYPE "Debug") # add_subdirectory(cxx) add_subdirectory(mcc) diff --git a/asibfm700/asibfm700_common.h b/asibfm700/asibfm700_common.h index 84fb71e..97b7181 100644 --- a/asibfm700/asibfm700_common.h +++ b/asibfm700/asibfm700_common.h @@ -12,6 +12,7 @@ #include #include "mcc_ccte_erfa.h" +#include "mcc_slewing_model.h" namespace asibfm700 { @@ -22,6 +23,6 @@ typedef mcc::ccte::erfa::MccCCTE_ERFA Asibfm700CCTE; typedef mcc::MccDefaultPCM Asibfm700PCM; typedef mcc::MccPZoneContainer Asibfm700PZoneContainer; typedef mcc::utils::MccSpdlogLogger Asibfm700Logger; - +typedef mcc::MccSimpleSlewingModel Asibfm700SlewingModel; } // namespace asibfm700 diff --git a/asibfm700/asibfm700_configfile.h b/asibfm700/asibfm700_configfile.h index 6c7f162..c14ff78 100644 --- a/asibfm700/asibfm700_configfile.h +++ b/asibfm700/asibfm700_configfile.h @@ -220,7 +220,7 @@ static auto Asibfm700MountConfigDefaults = std::make_tuple( // encoders polling interval in millisecs simple_config_record_t{"EncoderReqInterval", - std::chrono::milliseconds(50), + std::chrono::milliseconds(1), {"encoders polling interval in millisecs"}}, // mount axes rate calculation interval in millisecs @@ -746,7 +746,7 @@ public: fst << "\n"; }; - [&wrec, this](std::index_sequence) { + [&wrec](std::index_sequence) { (wrec.operator()(), ...); }(std::make_index_sequence>()); diff --git a/asibfm700/asibfm700_mount.cpp b/asibfm700/asibfm700_mount.cpp index dd5151f..4772d52 100644 --- a/asibfm700/asibfm700_mount.cpp +++ b/asibfm700/asibfm700_mount.cpp @@ -18,7 +18,7 @@ Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config, std::shared_p gm_class_t(std::make_tuple(config.servoControllerConfig()), std::make_tuple(this), std::make_tuple(), - std::make_tuple(this), + std::make_tuple(this, this), std::make_tuple(this), std::make_tuple(logger, Asibfm700Logger::LOGGER_DEFAULT_FORMAT)), // base_gm_class_t(Asibfm700StartState{}, @@ -31,7 +31,7 @@ Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config, std::shared_p _mountConfig(config), _mountConfigMutex(new std::mutex) { - addMarkToPatternIdx("[ASIB-MOUNT]"); + gm_class_t::addMarkToPatternIdx("[ASIB-MOUNT]"); logDebug("Create Asibfm700Mount class instance ({})", this->getThreadId()); diff --git a/asibfm700/asibfm700_mount.h b/asibfm700/asibfm700_mount.h index 7d6faaf..76855ce 100644 --- a/asibfm700/asibfm700_mount.h +++ b/asibfm700/asibfm700_mount.h @@ -21,14 +21,14 @@ class Asibfm700Mount : public Asibfm700CCTE, public mcc::MccGenericMount { typedef mcc::MccGenericMount gm_class_t; @@ -41,11 +41,16 @@ public: using Asibfm700CCTE::updateLeapSeconds; using Asibfm700CCTE::updateMeteoERFA; - using Asibfm700Logger::logCritical; - using Asibfm700Logger::logDebug; - using Asibfm700Logger::logError; - using Asibfm700Logger::logInfo; - using Asibfm700Logger::logWarn; + using gm_class_t::logCritical; + using gm_class_t::logDebug; + using gm_class_t::logError; + using gm_class_t::logInfo; + using gm_class_t::logWarn; + // using Asibfm700Logger::logCritical; + // using Asibfm700Logger::logDebug; + // using Asibfm700Logger::logError; + // using Asibfm700Logger::logInfo; + // using Asibfm700Logger::logWarn; // using Asibfm700PZoneContainer::addPZone; diff --git a/mcc/mcc_generic_mount.h b/mcc/mcc_generic_mount.h index 418a6c5..76185e8 100644 --- a/mcc/mcc_generic_mount.h +++ b/mcc/mcc_generic_mount.h @@ -180,12 +180,12 @@ public: std::tuple smodel_ctor_args, std::tuple tmodel_ctor_args, std::tuple log_ctor_args) - : HardwareT(std::make_from_tuple(std::move(hw_ctor_args))), + : LoggerT(std::make_from_tuple(std::move(log_ctor_args))), + HardwareT(std::make_from_tuple(std::move(hw_ctor_args))), TelemetryT(std::make_from_tuple(std::move(tm_ctor_args))), PZoneContT(std::make_from_tuple(std::move(pzcont_ctor_args))), SlewModelT(std::make_from_tuple(std::move(smodel_ctor_args))), TrackModelT(std::make_from_tuple(std::move(tmodel_ctor_args))), - LoggerT(std::make_from_tuple(std::move(log_ctor_args))), _mountStatus(new std::atomic{}) { *_mountStatus = mount_status_t::IDLE; diff --git a/mcc/mcc_slewing_model.h b/mcc/mcc_slewing_model.h index eccbc1e..92b8d60 100644 --- a/mcc/mcc_slewing_model.h +++ b/mcc/mcc_slewing_model.h @@ -118,17 +118,48 @@ public: typedef MccSimpleMovingModelParams slewing_params_t; - template - MccSimpleSlewingModel(CONTROLS_T* controls) + template + MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT* logger) : _stopSlewing(new std::atomic_bool()), _currentParamsMutex(new std::mutex) { + // logger->logDebug("Create MccSimpleSlewingModel class instance"); + *_stopSlewing = true; - _slewingFunc = [controls, this](bool slew_and_stop) -> error_t { + _slewingFunc = [controls, logger, this](bool slew_and_stop) -> error_t { // first, check target coordinates typename CONTROLS_T::error_t t_err; MccTelemetryData tdata; + double braking_accelX, braking_accelY; + + { + // std::lock_guard lock{*_currentParamsMutex}; + if (mcc::utils::isEqual(_currentParams.brakingAccelX, 0.0)) { + braking_accelX = std::numeric_limits::min(); + } else { + braking_accelX = std::abs(_currentParams.brakingAccelX); + } + + if (mcc::utils::isEqual(_currentParams.brakingAccelY, 0.0)) { + braking_accelY = std::numeric_limits::min(); + } else { + braking_accelY = std::abs(_currentParams.brakingAccelY); + } + } + + logger->logInfo( + std::format("Start slewing in mode '{}'", (slew_and_stop ? "SLEW-AND-STOP" : "SLEW-AND-TRACK"))); + logger->logInfo(std::format(" slewing process timeout: {} secs", _currentParams.slewTimeout.count())); + if (!slew_and_stop) { + logger->logInfo(std::format(" slewing tolerance radius: {} arcsecs", + mcc::MccAngle{_currentParams.slewToleranceRadius}.arcsecs())); + } + logger->logInfo(std::format(" braking acceleration X: {} degs/s^2 (in config: {} rads/s^2)", + mcc::MccAngle(braking_accelX).degrees(), _currentParams.brakingAccelX)); + logger->logInfo(std::format(" braking acceleration Y: {} degs/s^2 (in config: {} rads/s^2)", + mcc::MccAngle(braking_accelY).degrees(), _currentParams.brakingAccelY)); + { std::lock_guard lock{*_currentParamsMutex}; t_err = controls->telemetryData(&tdata); @@ -147,6 +178,16 @@ public: if (in_zone) { *_stopSlewing = true; + + logger->logError("target point is in prohibited zone!"); + 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(), mcc::MccAngle{tdata.target.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.target.ZD}.sexagesimal(), + mcc::MccAngle{tdata.target.ALT}.sexagesimal())); + return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE; } @@ -166,6 +207,7 @@ public: } if (*_stopSlewing) { + logger->logDebug("slewing was stopped!"); return MccSimpleSlewingModelErrorCode::ERROR_STOPPED; } @@ -191,10 +233,20 @@ public: hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_SLEWING; if (*_stopSlewing) { + logger->logDebug("slewing was stopped!"); return MccSimpleSlewingModelErrorCode::ERROR_STOPPED; } // start slewing + logger->logDebug(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y)); + if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) { + logger->logDebug(std::format(" target: HA = {}, DEC = {}", tdata.target.HA, tdata.target.DEC_APP)); + logger->logDebug(std::format(" mount: HA = {}, DEC = {}", tdata.HA, tdata.DEC_APP)); + } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) { + logger->logDebug(std::format(" target: AZ = {}, ZD = {}", tdata.target.AZ, tdata.target.ZD)); + logger->logDebug(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD)); + } + hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopSlewing = true; @@ -209,24 +261,8 @@ public: double dist; - bool adjust_mode = false; - static constexpr auto sideral_rate2 = slewing_params_t::sideralRate * slewing_params_t::sideralRate; - - double braking_accelX, braking_accelY; - { - std::lock_guard lock{*_currentParamsMutex}; - if (mcc::utils::isEqual(_currentParams.brakingAccelX, 0.0)) { - braking_accelX = std::numeric_limits::min(); - } else { - braking_accelX = std::abs(_currentParams.brakingAccelX); - } - - if (mcc::utils::isEqual(_currentParams.brakingAccelY, 0.0)) { - braking_accelY = std::numeric_limits::min(); - } else { - braking_accelY = std::abs(_currentParams.brakingAccelY); - } - } + // bool adjust_mode = false; + // static constexpr auto sideral_rate2 = slewing_params_t::sideralRate * slewing_params_t::sideralRate; std::chrono::steady_clock::time_point start_slewing_tp, last_adjust_tp; start_slewing_tp = std::chrono::steady_clock::now(); @@ -255,6 +291,10 @@ public: distXY = mcc_compute_distance(tdata, min_time_to_pzone_in_secs, braking_accelX, braking_accelY); + logger->logTrace( + std::format(" the distance that will be covered in the next {} seconds: X-axis: {}, Y-axis: {}", + min_time_to_pzone_in_secs, distXY.first, distXY.second)); + // calculate coordinates at current speed '_currentParams.minTimeToPZone' seconds ahead // and check them for getting into the prohibited zones if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) { @@ -269,6 +309,13 @@ public: if (cpt.Y < -DEG90INRADS) { cpt.Y = -DEG90INRADS; } + + logger->logTrace(std::format(" target: HA = {}, DEC = {}", + mcc::MccAngle(tdata.target.HA).sexagesimal(true), + mcc::MccAngle(tdata.target.DEC_APP).sexagesimal())); + logger->logTrace(std::format(" mount: HA = {}, DEC = {}", + mcc::MccAngle(tdata.HA).sexagesimal(true), + mcc::MccAngle(tdata.DEC_APP).sexagesimal())); } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) { cpt.X = tdata.AZ + distXY.first; cpt.Y = tdata.ZD + distXY.second; @@ -280,9 +327,14 @@ public: if (cpt.Y > std::numbers::pi) { cpt.Y = std::numbers::pi; } + + logger->logTrace(std::format(" target: AZ = {}, ZD = {}", tdata.target.AZ, tdata.target.ZD)); + logger->logTrace(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD)); } mcc_tp2tp(tdata.time_point, cpt.time_point); + logger->logTrace(std::format(" mount: speedX = {}, speedY = {}", tdata.speedX, tdata.speedY)); + pz_err = controls->inPZone(cpt, &in_zone); if (pz_err) { *_stopSlewing = true; @@ -300,28 +352,39 @@ public: std::lock_guard lock{*_currentParamsMutex}; if ((std::chrono::steady_clock::now() - start_slewing_tp) > _currentParams.slewTimeout) { + logger->logError("slewing process timeout!"); return MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT; } } - hw_err = controls->hardwareGetState(&hw_state); if (hw_err) { *_stopSlewing = true; return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE); } - if (slew_and_stop) { + if (slew_and_stop) { // just wait for mount to be stopped if (hw_state.moving_state == CONTROLS_T::hardware_moving_state_t::HW_MOVE_STOPPED) { + logger->logInfo("mount moving state is STOPPED - exit!"); break; } - } else { // just wait for mount to be stopped + } else { t_err = controls->targetToMountDist(&dist); if (t_err) { *_stopSlewing = true; return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY); } + + logger->logTrace(std::format(" target-to-mount distance: {} {}", + dist < 1.0_arcmins ? mcc::MccAngle(dist).arcsecs() + : dist < 1.0_degs ? mcc::MccAngle(dist).arcmins() + : mcc::MccAngle(dist).degrees(), + dist < 1.0_arcmins ? "arcsecs" + : dist < 1.0_degs ? "arcmins" + : "degs")); + if (dist <= _currentParams.slewToleranceRadius) { // stop slewing and exit from cycle + logger->logInfo("target-to-mount distance is lesser than slew tolerance radius - exit!"); break; } @@ -330,6 +393,7 @@ public: hw_state.X = (double)tdata.target.X; hw_state.Y = (double)tdata.target.Y; + logger->logTrace(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y)); hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopSlewing = true; @@ -417,6 +481,8 @@ public: *_stopSlewing = true; + logger->logInfo("Slewing finished"); + return MccSimpleSlewingModelErrorCode::ERROR_OK; }; }