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

61
mcc/mcc_slewing_model.h
View File

@ -9,6 +9,7 @@
#include "mcc_defaults.h"
#include "mcc_generics.h"
#include "mcc_moving_model_common.h"
#include "mcc_spdlog.h"
namespace mcc
{
@ -119,14 +120,14 @@ public:
typedef MccSimpleMovingModelParams slewing_params_t;
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)
{
// logger->logDebug("Create MccSimpleSlewingModel class instance");
logger.logDebug("Create MccSimpleSlewingModel class instance");
*_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
typename CONTROLS_T::error_t t_err;
MccTelemetryData tdata;
@ -148,16 +149,16 @@ public:
}
}
logger->logInfo(
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()));
logger.logInfo(std::format(" slewing process timeout: {} secs", _currentParams.slewTimeout.count()));
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()));
}
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));
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));
{
@ -179,12 +180,12 @@ public:
if (in_zone) {
*_stopSlewing = true;
logger->logError("target point is in prohibited zone!");
logger->logError(std::format(
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(),
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()));
@ -207,7 +208,7 @@ public:
}
if (*_stopSlewing) {
logger->logDebug("slewing was stopped!");
logger.logDebug("slewing was stopped!");
return MccSimpleSlewingModelErrorCode::ERROR_STOPPED;
}
@ -233,18 +234,18 @@ public:
hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_SLEWING;
if (*_stopSlewing) {
logger->logDebug("slewing was stopped!");
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));
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));
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));
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);
@ -291,7 +292,7 @@ public:
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: {}",
min_time_to_pzone_in_secs, distXY.first, distXY.second));
@ -310,10 +311,10 @@ public:
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.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.DEC_APP).sexagesimal()));
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
@ -328,12 +329,12 @@ public:
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));
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));
logger.logTrace(std::format(" mount: speedX = {}, speedY = {}", tdata.speedX, tdata.speedY));
pz_err = controls->inPZone(cpt, &in_zone);
if (pz_err) {
@ -352,7 +353,7 @@ public:
std::lock_guard lock{*_currentParamsMutex};
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;
}
}
@ -365,7 +366,7 @@ public:
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!");
logger.logInfo("mount moving state is STOPPED - exit!");
break;
}
} else {
@ -375,7 +376,7 @@ public:
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_degs ? mcc::MccAngle(dist).arcmins()
: mcc::MccAngle(dist).degrees(),
@ -384,7 +385,7 @@ public:
: "degs"));
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;
}
@ -393,7 +394,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));
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;
@ -481,7 +482,7 @@ public:
*_stopSlewing = true;
logger->logInfo("Slewing finished");
logger.logInfo("Slewing finished");
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)...);
}
protected:
std::list<std::string> _currentLogPatternRange;
std::string _currentLogPattern;
std::shared_ptr<spdlog::logger> _loggerSPtr;
// helper methods
@ -180,6 +175,12 @@ protected:
{
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