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

Compare commits

base: eddy:a42f6dbc983f6d108c16996a8e04d0783ab587d6
Branches Tags
eddy:main
..
compare: eddy:e529265a63b7de9a0b4316020b895b7e850ff4c4
Branches Tags
eddy:main

No commits in common. "a42f6dbc983f6d108c16996a8e04d0783ab587d6" and "e529265a63b7de9a0b4316020b895b7e850ff4c4" have entirely different histories.
a42f6dbc98 ... e529265a63

10 changed files with 65 additions and 249 deletions
Show Stats Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -13,7 +13,7 @@ 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")

2
asibfm700/asibfm700_common.h
View File

@ -13,7 +13,6 @@
#include "mcc_ccte_erfa.h"
#include "mcc_slewing_model.h"
#include "mcc_tracking_model.h"
namespace asibfm700
{
@ -25,6 +24,5 @@ typedef mcc::MccDefaultPCM<asibfm700MountType> Asibfm700PCM;
typedef mcc::MccPZoneContainer<mcc::MccTimeDuration> Asibfm700PZoneContainer;
typedef mcc::utils::MccSpdlogLogger Asibfm700Logger;
typedef mcc::MccSimpleSlewingModel Asibfm700SlewingModel;
typedef mcc::MccSimpleTrackingModel Asibfm700TrackingModel;
} // namespace asibfm700

4
asibfm700/asibfm700_configfile.h
View File

@ -183,10 +183,10 @@ static auto Asibfm700MountConfigDefaults = std::make_tuple(
simple_config_record_t{"pzMinAltitude", mcc::MccAngle(10.0_degs), {"minimal altitude"}},
// HA-axis limit switch minimal value
simple_config_record_t{"pzLimitSwitchHAMin", mcc::MccAngle(-270.0_degs), {"HA-axis limit switch minimal value"}},
simple_config_record_t{"pzLimitSwitchHAMin", mcc::MccAngle(-170.0_degs), {"HA-axis limit switch minimal value"}},
// HA-axis limit switch maximal value
simple_config_record_t{"pzLimitSwitchHAMax", mcc::MccAngle(270.0_degs), {"HA-axis limit switch maximal value"}},
simple_config_record_t{"pzLimitSwitchHAMax", mcc::MccAngle(170.0_degs), {"HA-axis limit switch maximal value"}},
// DEC-axis limit switch minimal value
simple_config_record_t{"pzLimitSwitchDecMin", mcc::MccAngle(-90.0_degs), {"DEC-axis limit switch minimal value"}},

10
asibfm700/asibfm700_mount.cpp
View File

@ -19,7 +19,7 @@ Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config, std::shared_p
std::make_tuple(this),
std::make_tuple(),
std::make_tuple(this, Asibfm700Logger{logger}),
std::make_tuple(this, Asibfm700Logger{logger}),
std::make_tuple(this),
std::make_tuple(logger, Asibfm700Logger::LOGGER_DEFAULT_FORMAT)),
// base_gm_class_t(Asibfm700StartState{},
// std::make_tuple(config.servoControllerConfig()),
@ -263,13 +263,7 @@ Asibfm700Mount::error_t Asibfm700Mount::initMount()
bool ok = isInternalTelemetryDataUpdating();
if (ok) {
logInfo("Start updating telemetry data ...");
mcc::MccTelemetryData tdata;
auto err = waitForTelemetryData(&tdata, _mountConfig.movingModelParams().telemetryTimeout);
if (err) {
logError("Cannot update telemetry data (err = {} [{}, {}])!", err.message(), err.value(),
err.category().name());
}
logInfo("Start updating telemetry data");
} else {
auto err = lastUpdateError();
logError("Cannot update telemetry data (err = {} [{}, {}])!", err.message(), err.value(),

4
asibfm700/asibfm700_mount.h
View File

@ -22,14 +22,14 @@ class Asibfm700Mount : public Asibfm700CCTE,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
Asibfm700SlewingModel,
Asibfm700TrackingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
{
typedef mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
Asibfm700SlewingModel,
Asibfm700TrackingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
gm_class_t;

2
asibfm700/asibfm700_servocontroller.cpp
View File

@ -115,7 +115,7 @@ AsibFM700ServoController::error_t AsibFM700ServoController::hardwareSetState(har
// according to"SiTech protocol notes" X is DEC-axis and Y is HA-axis
coordval_pair_t cvalpair{.X{.val = state.Y, .t = tp}, .Y{.val = state.X, .t = tp}};
coordpair_t cpair{.X = state.Y, .Y = state.X};
// coordpair_t cpair{.X = state.Y, .Y = state.X + mcc::MccAngle(1.0_degs)};
// coordpair_t cpair{.X = state.Y, .Y = state.X + mcc::MccAngle(10.0_arcsecs)};
// correctTo is asynchronous function!!!
//

3
mcc/mcc_ccte_erfa.h
View File

@ -506,8 +506,7 @@ public:
lst_eo();
if (!ret) {
// ha = MccAngle(lst - from_pt.X + eo).normalize<MccAngle::NORM_KIND_0_360>();
ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_180_180>();
// ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_0_360>();
ha = MccAngle(lst - from_pt.X - eo).normalize<MccAngle::NORM_KIND_0_360>();
} else {
return ret;
}

43
mcc/mcc_slewing_model.h
View File

@ -122,10 +122,7 @@ public:
MccSimpleSlewingModel(CONTROLS_T* controls, LoggerT logger)
: _stopSlewing(new std::atomic_bool()), _currentParamsMutex(new std::mutex)
{
std::ostringstream os;
os << std::this_thread::get_id();
logger.logDebug(std::format("Create MccSimpleSlewingModel class instance (thread: {})", os.str()));
logger.logDebug("Create MccSimpleSlewingModel class instance");
*_stopSlewing = true;
@ -177,8 +174,7 @@ public:
}
bool in_zone;
std::vector<bool> in_zone_vec;
auto pz_err = controls->inPZone(tdata.target, &in_zone, &in_zone_vec);
auto pz_err = controls->inPZone(tdata.target, &in_zone);
if (pz_err) {
*_stopSlewing = true;
return mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
@ -187,14 +183,7 @@ public:
if (in_zone) {
*_stopSlewing = true;
size_t i = 0;
for (; i < in_zone_vec.size(); ++i) {
if (in_zone_vec[i]) {
break;
}
}
logger.logError("target point is in prohibited zone (zone index: {})! Entered target coordinates:", i);
logger.logError("target point is in prohibited zone! Entered target coordinates:");
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(),
@ -204,9 +193,6 @@ public:
mcc::MccAngle{tdata.target.ZD}.sexagesimal(),
mcc::MccAngle{tdata.target.ALT}.sexagesimal()));
logger.logError(std::format(" hardware X, Y: {}, {}", mcc::MccAngle{tdata.target.X}.sexagesimal(),
mcc::MccAngle{tdata.target.Y}.sexagesimal()));
return MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE;
}
@ -324,20 +310,6 @@ public:
std::pair<double, double> distXY;
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
if (tdata.target.pair_kind != MccCoordPairKind::COORDS_KIND_HADEC_APP) {
// here, HA and DEC are changed during slewing process!!
slew_and_stop = false;
}
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
if (!(tdata.target.pair_kind == MccCoordPairKind::COORDS_KIND_AZALT &&
tdata.target.pair_kind == MccCoordPairKind::COORDS_KIND_AZZD)) {
slew_and_stop = false;
}
}
// main loop (simply monitors the current position taking into account the prohibited zones, as well as the
// timeout of the entire process)
while (!*_stopSlewing) {
@ -470,15 +442,8 @@ public:
return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
}
{
std::lock_guard lock{*_currentParamsMutex};
logger.logDebug(" the 'hardwareSetState' method performed successfully!");
}
logger.logDebug(" the 'hardwareSetState' method performed successfully!");
}
// sleep here
std::this_thread::sleep_for(_currentParams.slewingTelemetryInterval);
}
*_stopSlewing = true;

101
mcc/mcc_telemetry.h
View File

@ -9,7 +9,6 @@
#include <condition_variable>
#include <future>
#include <mutex>
#include <stop_token>
#include <thread>
#include "mcc_defaults.h"
@ -151,7 +150,7 @@ public:
MccCelestialPoint hw_cp{.pair_kind = MccCoordPairKind::COORDS_KIND_XY};
mcc_tp2tp(_data.time_point, hw_cp.time_point);
if (hw_coords) { // compute corresponded observed coordinates
if (hw_coords) { // compute corresponded apparent coordinates
hw_cp.X = _data.target.X;
hw_cp.Y = _data.target.Y;
@ -319,7 +318,6 @@ public:
MccCelestialPoint pt{.pair_kind = MccCoordPairKind::COORDS_KIND_AZALT, .time_point = _data.time_point};
if constexpr (mccIsEquatorialMount(pcm_t::mountType)) {
// NOTE: now it are OBSERVED (NOT APPARENT) RA, HA, DEC!!!
_data.RA_APP =
MccAngle((double)_data.LST - (double)_data.HA - eo).normalize<MccAngle::NORM_KIND_0_360>();
// MccAngle((double)_data.LST - (double)_data.HA + eo).normalize<MccAngle::NORM_KIND_0_360>();
@ -369,32 +367,18 @@ public:
ccte_err = controls->refractionCorrection(_data, &_data.refCorr);
if (!ccte_err) {
// // compute APPARENT RA, HA and DEC from observer AZ, ZD
// _data.Y += _data.refCorr; // zenithal distance corrected for the refraction
// pt.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP;
// ccte_err = controls->transformCoordinates(_data, &pt);
// if (!ccte_err) {
// _data.HA = pt.X;
// _data.DEC_APP = pt.Y;
// _data.RA_APP =
// MccAngle((double)_data.LST - (double)_data.HA -
// eo).normalize<MccAngle::NORM_KIND_0_360>();
// restore hardware encoders coordinates
_data.X = (double)hw_pos.X;
_data.Y = (double)hw_pos.Y;
// update target (assuming target ICRS coordinates are already set)
// auto ret = _updateTargetFunc(false, stop_token);
// update target according to its .pair_kind!
auto ret = _updateTargetFunc(stop_token);
if (ret) {
return ret;
}
// }
}
}
@ -423,35 +407,32 @@ public:
_dataUpdatingRequested->clear();
_dataUpdatingStart->clear();
_updatingFuture =
std::async(std::launch::async, &MccTelemetry::updateLoop, this, _internalUpdatingStopSource.get_token());
_updatingFuture = std::async(
std::launch::async,
[controls, this](std::stop_token stoken) {
bool stop_flag = stoken.stop_requested();
// controls->logTrace(std::format("stop_requested() = {}", stop_flag));
// while (!stoken.stop_requested()) {
while (!stop_flag) {
_dataUpdatingRequested->wait(false);
// _updatingFuture = std::async(
// std::launch::async,
// [controls, this](std::stop_token stoken) {
// bool stop_flag = stoken.stop_requested();
// // controls->logTrace(std::format("stop_requested() = {}", stop_flag));
// // while (!stoken.stop_requested()) {
// while (!stop_flag) {
// _dataUpdatingRequested->wait(false);
stop_flag = stoken.stop_requested();
if (!stop_flag) {
// if (!stoken.stop_requested()) {
*_internalUpdating = true;
std::lock_guard lock{*_timeoutMutex};
// stop_flag = stoken.stop_requested();
// if (!stop_flag) {
// // if (!stoken.stop_requested()) {
// *_internalUpdating = true;
// std::lock_guard lock{*_timeoutMutex};
_dataUpdatingStart->test_and_set();
_dataUpdatingStart->notify_all();
// _dataUpdatingStart->test_and_set();
// _dataUpdatingStart->notify_all();
_lastUpdateError = _updateFunc(stoken);
// _lastUpdateError = _updateFunc(stoken);
// _dataUpdatingStart->clear();
// _dataUpdatingRequested->clear();
// }
// }
// },
// _internalUpdatingStopSource.get_token());
_dataUpdatingStart->clear();
_dataUpdatingRequested->clear();
}
}
},
_internalUpdatingStopSource.get_token());
}
@ -530,14 +511,11 @@ public:
_lastUpdateError = MccTelemetryErrorCode::ERROR_UPDATE_LOOP_WAIT;
}
_updatingFuture = std::async(std::launch::async, &MccTelemetry::updateLoop, this,
_internalUpdatingStopSource.get_token());
startInternalTelemetryDataUpdating();
*_internalUpdating = true;
} else {
_updatingFuture = std::async(std::launch::async, &MccTelemetry::updateLoop, this,
_internalUpdatingStopSource.get_token());
startInternalTelemetryDataUpdating();
*_internalUpdating = true;
}
@ -750,31 +728,6 @@ protected:
std::unique_ptr<std::timed_mutex> _timeoutMutex{new std::timed_mutex()};
error_t _lastUpdateError{MccTelemetryErrorCode::ERROR_OK};
void updateLoop(std::stop_token stoken)
{
bool stop_flag = stoken.stop_requested();
// controls->logTrace(std::format("stop_requested() = {}", stop_flag));
while (!stoken.stop_requested()) {
// while (!stop_flag) {
_dataUpdatingRequested->wait(false);
// stop_flag = stoken.stop_requested();
// if (!stop_flag) {
if (!stoken.stop_requested()) {
*_internalUpdating = true;
std::lock_guard lock{*_timeoutMutex};
_dataUpdatingStart->test_and_set();
_dataUpdatingStart->notify_all();
_lastUpdateError = _updateFunc(stoken);
_dataUpdatingStart->clear();
_dataUpdatingRequested->clear();
}
}
}
};

143
mcc/mcc_tracking_model.h
View File

@ -22,7 +22,6 @@ enum class MccSimpleTrackingModelErrorCode : int {
ERROR_DIST_TELEMETRY,
ERROR_PZONE_CONTAINER_COMP,
ERROR_NEAR_PZONE,
ERROR_IN_PZONE,
ERROR_ALREADY_TRACK,
ERROR_ALREADY_STOPPED,
ERROR_STOPPED
@ -79,8 +78,6 @@ struct MccSimpleTrackingModelCategory : public std::error_category {
return "pzone container computation error";
case MccSimpleTrackingModelErrorCode::ERROR_NEAR_PZONE:
return "near prohibited zone";
case MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE:
return "in prohibited zone";
case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_TRACK:
return "already tracking";
case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_STOPPED:
@ -113,18 +110,13 @@ public:
typedef MccSimpleMovingModelParams tracking_params_t;
template <mcc_all_controls_c CONTROLS_T, mcc_logger_c LoggerT = MccNullLogger>
MccSimpleTrackingModel(CONTROLS_T* controls, LoggerT logger)
template <mcc_all_controls_c CONTROLS_T>
MccSimpleTrackingModel(CONTROLS_T* controls)
: _stopTracking(new std::atomic_bool()), _currentParamsMutex(new std::mutex())
{
std::ostringstream os;
os << std::this_thread::get_id();
logger.logDebug(std::format("Create MccSimpleTrackingModel class instance (thread: {})", os.str()));
*_stopTracking = true;
_trackingFunc = [logger = std::move(logger), controls, this]() mutable -> error_t {
_trackingFunc = [controls, this]() -> error_t {
typename CONTROLS_T::hardware_state_t hw_state;
MccTelemetryData tdata;
@ -136,43 +128,17 @@ public:
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
target_in_future_pt.pair_kind = MccCoordPairKind::COORDS_KIND_AZZD;
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
static_assert(false, "UNKNOW MOUNT TYPE!");
}
// double dist, dx, dy;
logger.logInfo("Start tracking:");
logger.logInfo(" min time to pzone: {} secs", _currentParams.minTimeToPZone.count());
auto t_err = controls->telemetryData(&tdata);
if (t_err) {
*_stopTracking = true;
return mcc_deduce_error_code(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY);
}
bool in_zone;
auto pz_err = controls->inPZone(tdata, &in_zone);
if (pz_err) {
return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
if (in_zone) {
logger.logError("mount current coordinates are in prohibited zone:");
logger.logError(std::format(
" RA-APP, DEC-APP, HA, LST: {}, {}, {}, {}", mcc::MccAngle{tdata.RA_APP}.sexagesimal(true),
mcc::MccAngle{tdata.DEC_APP}.sexagesimal(), mcc::MccAngle{tdata.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.ZD}.sexagesimal(),
mcc::MccAngle{tdata.ALT}.sexagesimal()));
logger.logError(std::format(" hardware X, Y: {}, {}", mcc::MccAngle{tdata.X}.sexagesimal(),
mcc::MccAngle{tdata.Y}.sexagesimal()));
return MccSimpleTrackingModelErrorCode::ERROR_IN_PZONE;
}
bool no_intersects = false;
@ -202,7 +168,7 @@ public:
no_intersects = true;
}
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
static_assert(false, "UNKNOW MOUNT TYPE!");
}
return MccSimpleTrackingModelErrorCode::ERROR_OK;
@ -217,12 +183,10 @@ public:
_currentParams.timeShiftToTargetPoint);
// point in +time_dist future
MccCelestialPoint pt{.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP,
// .X = MccAngle(dt.count() * std::numbers::pi / 3600.0
// / 15.0).normalize<MccAngle::NORM_KIND_0_360>(),
.X = MccAngle(dt.count() * std::numbers::pi / 3600.0 / 15.0)
.normalize<MccAngle::NORM_KIND_180_180>(),
.Y = tdata.DEC_APP};
MccCelestialPoint pt{
.pair_kind = MccCoordPairKind::COORDS_KIND_HADEC_APP,
.X = MccAngle(dt.count() * std::numbers::pi / 3600.0 / 15.0).normalize<MccAngle::NORM_KIND_0_360>(),
.Y = tdata.DEC_APP};
mcc_tp2tp(tdata.time_point + tp_dt, pt.time_point);
point->time_point = pt.time_point;
@ -258,7 +222,7 @@ public:
};
pz_err = update_pzones_ipoint();
auto pz_err = update_pzones_ipoint();
if (pz_err) {
*_stopTracking = true;
return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
@ -279,31 +243,15 @@ public:
hw_state.speedX = _currentParams.trackSpeedX;
hw_state.speedY = _currentParams.trackSpeedY;
}
logger.logTrace("The updated target point:");
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
logger.logTrace(" HA, DEC: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(true),
MccAngle(target_in_future_pt.Y).sexagesimal());
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
logger.logTrace(" AZ, ZD: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(),
MccAngle(target_in_future_pt.Y).sexagesimal());
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
}
}
// move mount
logger.logDebug(std::format("Send to hardware: X = {} degs, Y = {} degs",
mcc::MccAngle{hw_state.X}.degrees(), mcc::MccAngle{hw_state.Y}.degrees()));
auto hw_err = controls->hardwareSetState(hw_state);
if (hw_err) {
*_stopTracking = true;
return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
}
logger.logDebug(" the 'hardwareSetState' method performed successfully!");
std::chrono::steady_clock::time_point last_corr_tp, last_ipzone_update_tp;
last_corr_tp = std::chrono::steady_clock::now();
@ -322,26 +270,6 @@ public:
}
}
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
logger.logTrace(std::format(" current target: HA = {}, DEC = {}",
mcc::MccAngle(tdata.target.HA).sexagesimal(true),
mcc::MccAngle(tdata.target.DEC_APP).sexagesimal()));
logger.logTrace(std::format(" current mount: HA = {}, DEC = {}",
mcc::MccAngle(tdata.HA).sexagesimal(true),
mcc::MccAngle(tdata.DEC_APP).sexagesimal()));
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
logger.logTrace(std::format(" target: AZ = {}, ZD = {}",
mcc::MccAngle(tdata.target.AZ).sexagesimal(),
mcc::MccAngle(tdata.target.ZD).sexagesimal()));
logger.logTrace(std::format(" mount: AZ = {}, ZD = {}", mcc::MccAngle(tdata.AZ).sexagesimal(),
mcc::MccAngle(tdata.ZD).sexagesimal()));
}
logger.logTrace(std::format(" mount: speedX = {}/s, speedY = {}/s",
mcc::MccAngleFancyString(tdata.speedX),
mcc::MccAngleFancyString(tdata.speedY)));
if (*_stopTracking) {
break;
}
@ -364,56 +292,35 @@ public:
std::lock_guard lock{*_currentParamsMutex};
auto now = std::chrono::steady_clock::now();
if ((now - last_corr_tp) > _currentParams.trackingCycleInterval) {
// update prohibited zones intersection point
if ((now - last_ipzone_update_tp) < _currentParams.updatingPZoneInterval) {
pz_err = update_pzones_ipoint();
if (pz_err) {
*_stopTracking = true;
return mcc_deduce_error_code(
pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
}
if ((now - last_corr_tp) < _currentParams.trackingCycleInterval) {
continue;
}
// compute new target-in-future point
auto ccte_err = target_point(&target_in_future_pt);
if (ccte_err) {
// update prohibited zones intersection point
if ((now - last_ipzone_update_tp) < _currentParams.updatingPZoneInterval) {
pz_err = update_pzones_ipoint();
if (pz_err) {
*_stopTracking = true;
return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE);
return mcc_deduce_error_code(pz_err,
MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP);
}
}
logger.logTrace("The updated target point:");
if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) {
logger.logTrace(" HA, DEC: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(true),
MccAngle(target_in_future_pt.Y).sexagesimal());
} else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) {
logger.logTrace(" AZ, ZD: {} {}", MccAngle(target_in_future_pt.X).sexagesimal(),
MccAngle(target_in_future_pt.Y).sexagesimal());
} else {
static_assert(false, "UNKNOWN MOUNT TYPE!");
}
// compute new target-in-future point
auto ccte_err = target_point(&target_in_future_pt);
if (ccte_err) {
*_stopTracking = true;
return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE);
}
}
// send corrections
logger.logDebug(std::format("Send to hardware: X = {} degs, Y = {} degs",
mcc::MccAngle{hw_state.X}.degrees(), mcc::MccAngle{hw_state.Y}.degrees()));
hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_TRACKING;
hw_err = controls->hardwareSetState(hw_state);
if (hw_err) {
*_stopTracking = true;
return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
}
logger.logDebug(" the 'hardwareSetState' method performed successfully!");
// sleep here
{
std::lock_guard lock{*_currentParamsMutex};
std::this_thread::sleep_for(_currentParams.trackingTelemetryInterval);
}
}
return MccSimpleTrackingModelErrorCode::ERROR_OK;