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

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin 2025-11-16 10:34:17 +03:00
parent e18066e4a6
commit 0ce4430668
3 changed files with 53 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
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()), gm_class_t(std::make_tuple(config.servoControllerConfig()),
std::make_tuple(this), std::make_tuple(this),
std::make_tuple(), std::make_tuple(),
std::make_tuple(this, this), std::make_tuple(this, Asibfm700Logger{logger}),
std::make_tuple(this), std::make_tuple(this),
std::make_tuple(logger, Asibfm700Logger::LOGGER_DEFAULT_FORMAT)), std::make_tuple(logger, Asibfm700Logger::LOGGER_DEFAULT_FORMAT)),
// base_gm_class_t(Asibfm700StartState{}, // base_gm_class_t(Asibfm700StartState{},

91
mcc/mcc_slewing_model.h
View File

@ -9,6 +9,7 @@
#include "mcc_defaults.h" #include "mcc_defaults.h"
#include "mcc_generics.h" #include "mcc_generics.h"
#include "mcc_moving_model_common.h" #include "mcc_moving_model_common.h"
#include "mcc_spdlog.h"
namespace mcc namespace mcc
{ {
@ -119,14 +120,14 @@ public:
typedef MccSimpleMovingModelParams slewing_params_t; typedef MccSimpleMovingModelParams slewing_params_t;
template <mcc_all_controls_c CONTROLS_T, mcc_logger_c LoggerT = MccNullLogger> template <mcc_all_controls_c CONTROLS_T, mcc_logger_c LoggerT = MccNullLogger>
MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT* logger) MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT logger)
: _stopSlewing(new std::atomic_bool()), _currentParamsMutex(new std::mutex) : _stopSlewing(new std::atomic_bool()), _currentParamsMutex(new std::mutex)
{ {
// logger->logDebug("Create MccSimpleSlewingModel class instance"); logger.logDebug("Create MccSimpleSlewingModel class instance");
*_stopSlewing = true; *_stopSlewing = true;
_slewingFunc = [controls, logger, this](bool slew_and_stop) -> error_t { _slewingFunc = [controls, logger = std::move(logger), this](bool slew_and_stop) mutable -> error_t {
// first, check target coordinates // first, check target coordinates
typename CONTROLS_T::error_t t_err; typename CONTROLS_T::error_t t_err;
MccTelemetryData tdata; MccTelemetryData tdata;
@ -148,17 +149,17 @@ public:
} }
} }
logger->logInfo( logger.logInfo(
std::format("Start slewing in mode '{}'", (slew_and_stop ? "SLEW-AND-STOP" : "SLEW-AND-TRACK"))); 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())); logger.logInfo(std::format(" slewing process timeout: {} secs", _currentParams.slewTimeout.count()));
if (!slew_and_stop) { if (!slew_and_stop) {
logger->logInfo(std::format(" slewing tolerance radius: {} arcsecs", logger.logInfo(std::format(" slewing tolerance radius: {} arcsecs",
mcc::MccAngle{_currentParams.slewToleranceRadius}.arcsecs())); mcc::MccAngle{_currentParams.slewToleranceRadius}.arcsecs()));
} }
logger->logInfo(std::format(" braking acceleration X: {} degs/s^2 (in config: {} rads/s^2)", logger.logInfo(std::format(" braking acceleration X: {} degs/s^2 (in config: {} rads/s^2)",
mcc::MccAngle(braking_accelX).degrees(), _currentParams.brakingAccelX)); mcc::MccAngle(braking_accelX).degrees(), _currentParams.brakingAccelX));
logger->logInfo(std::format(" braking acceleration Y: {} degs/s^2 (in config: {} rads/s^2)", logger.logInfo(std::format(" braking acceleration Y: {} degs/s^2 (in config: {} rads/s^2)",
mcc::MccAngle(braking_accelY).degrees(), _currentParams.brakingAccelY)); mcc::MccAngle(braking_accelY).degrees(), _currentParams.brakingAccelY));
{ {
std::lock_guard lock{*_currentParamsMutex}; std::lock_guard lock{*_currentParamsMutex};
@ -179,14 +180,14 @@ public:
if (in_zone) { if (in_zone) {
*_stopSlewing = true; *_stopSlewing = true;
logger->logError("target point is in prohibited zone!"); logger.logError("target point is in prohibited zone!");
logger->logError(std::format( logger.logError(std::format(
"RA-APP, DEC-APP, HA, LST: {}, {}, {}, {}", mcc::MccAngle{tdata.target.RA_APP}.sexagesimal(true), "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.target.DEC_APP}.sexagesimal(), mcc::MccAngle{tdata.target.HA}.sexagesimal(true),
mcc::MccAngle{tdata.LST}.sexagesimal(true))); mcc::MccAngle{tdata.LST}.sexagesimal(true)));
logger->logError(std::format("AZ, ZD, ALT: {}, {}, {}", mcc::MccAngle{tdata.target.AZ}.sexagesimal(), logger.logError(std::format("AZ, ZD, ALT: {}, {}, {}", mcc::MccAngle{tdata.target.AZ}.sexagesimal(),
mcc::MccAngle{tdata.target.ZD}.sexagesimal(), mcc::MccAngle{tdata.target.ZD}.sexagesimal(),
mcc::MccAngle{tdata.target.ALT}.sexagesimal())); mcc::MccAngle{tdata.target.ALT}.sexagesimal()));
return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE; return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE;
} }
@ -207,7 +208,7 @@ public:
} }
if (*_stopSlewing) { if (*_stopSlewing) {
logger->logDebug("slewing was stopped!"); logger.logDebug("slewing was stopped!");
return MccSimpleSlewingModelErrorCode::ERROR_STOPPED; return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
} }
@ -233,18 +234,18 @@ public:
hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_SLEWING; hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_SLEWING;
if (*_stopSlewing) { if (*_stopSlewing) {
logger->logDebug("slewing was stopped!"); logger.logDebug("slewing was stopped!");
return MccSimpleSlewingModelErrorCode::ERROR_STOPPED; return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
} }
// start slewing // start slewing
logger->logDebug(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y)); logger.logDebug(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y));
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) { if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
logger->logDebug(std::format(" target: HA = {}, DEC = {}", tdata.target.HA, tdata.target.DEC_APP)); 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)); logger.logDebug(std::format(" mount: HA = {}, DEC = {}", tdata.HA, tdata.DEC_APP));
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) { } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
logger->logDebug(std::format(" target: AZ = {}, ZD = {}", tdata.target.AZ, tdata.target.ZD)); logger.logDebug(std::format(" target: AZ = {}, ZD = {}", tdata.target.AZ, tdata.target.ZD));
logger->logDebug(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD)); logger.logDebug(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD));
} }
hw_err = controls->hardwareSetState(hw_state); hw_err = controls->hardwareSetState(hw_state);
@ -291,7 +292,7 @@ public:
distXY = mcc_compute_distance(tdata, min_time_to_pzone_in_secs, braking_accelX, braking_accelY); distXY = mcc_compute_distance(tdata, min_time_to_pzone_in_secs, braking_accelX, braking_accelY);
logger->logTrace( logger.logTrace(
std::format(" the distance that will be covered in the next {} seconds: X-axis: {}, Y-axis: {}", 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)); min_time_to_pzone_in_secs, distXY.first, distXY.second));
@ -310,12 +311,12 @@ public:
cpt.Y = -DEG90INRADS; cpt.Y = -DEG90INRADS;
} }
logger->logTrace(std::format(" target: HA = {}, DEC = {}", logger.logTrace(std::format(" target: HA = {}, DEC = {}",
mcc::MccAngle(tdata.target.HA).sexagesimal(true), mcc::MccAngle(tdata.target.HA).sexagesimal(true),
mcc::MccAngle(tdata.target.DEC_APP).sexagesimal())); mcc::MccAngle(tdata.target.DEC_APP).sexagesimal()));
logger->logTrace(std::format(" mount: HA = {}, DEC = {}", logger.logTrace(std::format(" mount: HA = {}, DEC = {}",
mcc::MccAngle(tdata.HA).sexagesimal(true), mcc::MccAngle(tdata.HA).sexagesimal(true),
mcc::MccAngle(tdata.DEC_APP).sexagesimal())); mcc::MccAngle(tdata.DEC_APP).sexagesimal()));
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) { } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
cpt.X = tdata.AZ + distXY.first; cpt.X = tdata.AZ + distXY.first;
cpt.Y = tdata.ZD + distXY.second; cpt.Y = tdata.ZD + distXY.second;
@ -328,12 +329,12 @@ public:
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(" target: AZ = {}, ZD = {}", tdata.target.AZ, tdata.target.ZD));
logger->logTrace(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD)); logger.logTrace(std::format(" mount: AZ = {}, ZD = {}", tdata.AZ, tdata.ZD));
} }
mcc_tp2tp(tdata.time_point, cpt.time_point); mcc_tp2tp(tdata.time_point, cpt.time_point);
logger->logTrace(std::format(" mount: speedX = {}, speedY = {}", tdata.speedX, tdata.speedY)); logger.logTrace(std::format(" mount: speedX = {}, speedY = {}", tdata.speedX, tdata.speedY));
pz_err = controls->inPZone(cpt, &in_zone); pz_err = controls->inPZone(cpt, &in_zone);
if (pz_err) { if (pz_err) {
@ -352,7 +353,7 @@ public:
std::lock_guard lock{*_currentParamsMutex}; std::lock_guard lock{*_currentParamsMutex};
if ((std::chrono::steady_clock::now() - start_slewing_tp) > _currentParams.slewTimeout) { if ((std::chrono::steady_clock::now() - start_slewing_tp) > _currentParams.slewTimeout) {
logger->logError("slewing process timeout!"); logger.logError("slewing process timeout!");
return MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT; return MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT;
} }
} }
@ -365,7 +366,7 @@ public:
if (slew_and_stop) { // just wait for mount to be stopped 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) { if (hw_state.moving_state == CONTROLS_T::hardware_moving_state_t::HW_MOVE_STOPPED) {
logger->logInfo("mount moving state is STOPPED - exit!"); logger.logInfo("mount moving state is STOPPED - exit!");
break; break;
} }
} else { } else {
@ -375,16 +376,16 @@ public:
return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY); return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY);
} }
logger->logTrace(std::format(" target-to-mount distance: {} {}", logger.logTrace(std::format(" target-to-mount distance: {} {}",
dist < 1.0_arcmins ? mcc::MccAngle(dist).arcsecs() dist < 1.0_arcmins ? mcc::MccAngle(dist).arcsecs()
: dist < 1.0_degs ? mcc::MccAngle(dist).arcmins() : dist < 1.0_degs ? mcc::MccAngle(dist).arcmins()
: mcc::MccAngle(dist).degrees(), : mcc::MccAngle(dist).degrees(),
dist < 1.0_arcmins ? "arcsecs" dist < 1.0_arcmins ? "arcsecs"
: dist < 1.0_degs ? "arcmins" : dist < 1.0_degs ? "arcmins"
: "degs")); : "degs"));
if (dist <= _currentParams.slewToleranceRadius) { // stop slewing and exit from cycle if (dist <= _currentParams.slewToleranceRadius) { // stop slewing and exit from cycle
logger->logInfo("target-to-mount distance is lesser than slew tolerance radius - exit!"); logger.logInfo("target-to-mount distance is lesser than slew tolerance radius - exit!");
break; break;
} }
@ -393,7 +394,7 @@ public:
hw_state.X = (double)tdata.target.X; hw_state.X = (double)tdata.target.X;
hw_state.Y = (double)tdata.target.Y; hw_state.Y = (double)tdata.target.Y;
logger->logTrace(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y)); logger.logTrace(std::format("Send to hardware: X = {}, Y = {}", hw_state.X, hw_state.Y));
hw_err = controls->hardwareSetState(hw_state); hw_err = controls->hardwareSetState(hw_state);
if (hw_err) { if (hw_err) {
*_stopSlewing = true; *_stopSlewing = true;
@ -481,7 +482,7 @@ public:
*_stopSlewing = true; *_stopSlewing = true;
logger->logInfo("Slewing finished"); logger.logInfo("Slewing finished");
return MccSimpleSlewingModelErrorCode::ERROR_OK; return MccSimpleSlewingModelErrorCode::ERROR_OK;
}; };

11
mcc/mcc_spdlog.h
View File

@ -135,11 +135,6 @@ public:
_loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...); _loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
} }
protected:
std::list<std::string> _currentLogPatternRange;
std::string _currentLogPattern;
std::shared_ptr<spdlog::logger> _loggerSPtr;
// helper methods // helper methods
@ -180,6 +175,12 @@ protected:
{ {
addMarkToPatternIdx(std::string_view{mark}, after_idx); addMarkToPatternIdx(std::string_view{mark}, after_idx);
} }
protected:
std::list<std::string> _currentLogPatternRange;
std::string _currentLogPattern;
std::shared_ptr<spdlog::logger> _loggerSPtr;
}; };
} // namespace mcc::utils } // namespace mcc::utils