eddy/mountcontrol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add logging in MccSimpleSlewingModel class

Browse Source
This commit is contained in:
Timur A. Fatkhullin 2025-11-16 00:58:56 +03:00
parent 1c774d2d69
commit e18066e4a6
7 changed files with 112 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -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)

3
asibfm700/asibfm700_common.h
View File

@ -12,6 +12,7 @@
#include <mcc_spdlog.h>
#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<asibfm700MountType> Asibfm700PCM;
typedef mcc::MccPZoneContainer<mcc::MccTimeDuration> Asibfm700PZoneContainer;
typedef mcc::utils::MccSpdlogLogger Asibfm700Logger;
typedef mcc::MccSimpleSlewingModel Asibfm700SlewingModel;
} // namespace asibfm700

4
asibfm700/asibfm700_configfile.h
View File

@ -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]<size_t... Is>(std::index_sequence<Is...>) {
[&wrec]<size_t... Is>(std::index_sequence<Is...>) {
(wrec.operator()<Is>(), ...);
}(std::make_index_sequence<std::tuple_size_v<decltype(Asibfm700MountConfigDefaults)>>());

4
asibfm700/asibfm700_mount.cpp
View File

@ -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());

19
asibfm700/asibfm700_mount.h
View File

@ -21,14 +21,14 @@ class Asibfm700Mount : public Asibfm700CCTE,
public mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
Asibfm700SlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
{
typedef mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
Asibfm700SlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
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;

4
mcc/mcc_generic_mount.h
View File

@ -180,12 +180,12 @@ public:
std::tuple<SlewModelCtorArgTs...> smodel_ctor_args,
std::tuple<TrackModelCtorArgTs...> tmodel_ctor_args,
std::tuple<LoggerCtorArgTs...> log_ctor_args)
: HardwareT(std::make_from_tuple<HardwareT>(std::move(hw_ctor_args))),
: LoggerT(std::make_from_tuple<LoggerT>(std::move(log_ctor_args))),
HardwareT(std::make_from_tuple<HardwareT>(std::move(hw_ctor_args))),
TelemetryT(std::make_from_tuple<TelemetryT>(std::move(tm_ctor_args))),
PZoneContT(std::make_from_tuple<PZoneContT>(std::move(pzcont_ctor_args))),
SlewModelT(std::make_from_tuple<SlewModelT>(std::move(smodel_ctor_args))),
TrackModelT(std::make_from_tuple<TrackModelT>(std::move(tmodel_ctor_args))),
LoggerT(std::make_from_tuple<LoggerT>(std::move(log_ctor_args))),
_mountStatus(new std::atomic<mount_status_t>{})
{
*_mountStatus = mount_status_t::IDLE;

114
mcc/mcc_slewing_model.h
View File

@ -118,17 +118,48 @@ public:
typedef MccSimpleMovingModelParams slewing_params_t;
template <mcc_all_controls_c CONTROLS_T>
MccSimpleSlewingModel(CONTROLS_T* controls)
template <mcc_all_controls_c CONTROLS_T, mcc_logger_c LoggerT = MccNullLogger>
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<double>::min();
} else {
braking_accelX = std::abs(_currentParams.brakingAccelX);
}
if (mcc::utils::isEqual(_currentParams.brakingAccelY, 0.0)) {
braking_accelY = std::numeric_limits<double>::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<double>::min();
} else {
braking_accelX = std::abs(_currentParams.brakingAccelX);
}
if (mcc::utils::isEqual(_currentParams.brakingAccelY, 0.0)) {
braking_accelY = std::numeric_limits<double>::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;
};
}