From 281ceacf896a08cd7c2a28a7ae4475dff1480670 Mon Sep 17 00:00:00 2001 From: "Timur A. Fatkhullin" Date: Wed, 17 Sep 2025 12:51:28 +0300 Subject: [PATCH] ... --- asibfm700/asibfm700_mount.cpp | 30 +- asibfm700/asibfm700_mount.h | 62 +--- mcc/mcc_generic_mount.h | 548 +++++----------------------------- mcc/mcc_pzone.h | 8 +- mcc/mcc_pzone_container.h | 26 +- mcc/mcc_slewing_model.h | 84 +++++- mcc/mcc_telemetry.h | 14 +- mcc/mcc_tracking_model.h | 89 ++++-- 8 files changed, 259 insertions(+), 602 deletions(-) diff --git a/asibfm700/asibfm700_mount.cpp b/asibfm700/asibfm700_mount.cpp index 8b6abe9..ac53054 100644 --- a/asibfm700/asibfm700_mount.cpp +++ b/asibfm700/asibfm700_mount.cpp @@ -4,36 +4,10 @@ namespace asibfm700 { + Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config, std::shared_ptr logger, const auto& pattern_range) - : mcc::ccte::erfa::MccCCTE_ERFA({.meteo{.temperature = 10.0, .humidity = 0.5, .pressure = 1010.0}, - .wavelength = config.refractWavelength, - .lat = config.siteLatitude, - .lon = config.siteLongitude, - .elev = config.siteElevation}), - Asibfm700PCM(config.pcmData), - base_gm_class_t(AsibFM700ServoController{config.servoControllerConfig}, - mcc::MccTelemetry{this}, - Asibfm700PZoneContainer{}, - mcc::MccSimpleSlewingModel{this}, - mcc::MccSimpleTrackingModel{this}, - Asibfm700Logger{std::move(logger), pattern_range}) -{ - logDebug("Create Asibfm700Mount class instance ({})", this->getThreadId()); -} - - -Asibfm700Mount::~Asibfm700Mount() -{ - logDebug("Delete Asibfm700Mount class instance ({})", this->getThreadId()); -} - - - -Asibfm700Mount1::Asibfm700Mount1(Asibfm700MountConfig const& config, - std::shared_ptr logger, - const auto& pattern_range) : mcc::ccte::erfa::MccCCTE_ERFA({.meteo{.temperature = 10.0, .humidity = 0.5, .pressure = 1010.0}, .wavelength = config.refractWavelength, .lat = config.siteLatitude, @@ -48,7 +22,7 @@ Asibfm700Mount1::Asibfm700Mount1(Asibfm700MountConfig const& config, logDebug("Create Asibfm700Mount class instance ({})", this->getThreadId()); } -Asibfm700Mount1::~Asibfm700Mount1() +Asibfm700Mount::~Asibfm700Mount() { logDebug("Delete Asibfm700Mount class instance ({})", this->getThreadId()); } diff --git a/asibfm700/asibfm700_mount.h b/asibfm700/asibfm700_mount.h index 06b6dcd..85d4efd 100644 --- a/asibfm700/asibfm700_mount.h +++ b/asibfm700/asibfm700_mount.h @@ -17,52 +17,16 @@ namespace asibfm700 { + + class Asibfm700Mount : public mcc::ccte::erfa::MccCCTE_ERFA, public mcc::MccDefaultPCM, - public mcc::MccGenericMountFSM -{ - typedef mcc::MccGenericMountFSM - base_gm_class_t; - -public: - using base_gm_class_t::error_t; - - using mcc::ccte::erfa::MccCCTE_ERFA::setStateERFA; - using mcc::ccte::erfa::MccCCTE_ERFA::updateBulletinA; - using mcc::ccte::erfa::MccCCTE_ERFA::updateLeapSeconds; - using mcc::ccte::erfa::MccCCTE_ERFA::updateMeteoERFA; - - using Asibfm700Logger::logCritical; - using Asibfm700Logger::logDebug; - using Asibfm700Logger::logError; - using Asibfm700Logger::logInfo; - using Asibfm700Logger::logWarn; - - Asibfm700Mount(Asibfm700MountConfig const& config, - std::shared_ptr logger, - const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT); - - ~Asibfm700Mount(); -}; - -class Asibfm700Mount1 : public mcc::ccte::erfa::MccCCTE_ERFA, - public mcc::MccDefaultPCM, - public mcc::MccGenericFsmMount> + public mcc::MccGenericFsmMount> { typedef mcc::MccGenericMount logger, - const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT); + Asibfm700Mount(Asibfm700MountConfig const& config, + std::shared_ptr logger, + const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT); - ~Asibfm700Mount1(); + ~Asibfm700Mount(); }; static_assert(mcc::mcc_position_controls_c, ""); static_assert(mcc::mcc_all_controls_c, ""); static_assert(mcc::mcc_generic_mount_c, ""); -static_assert(mcc::mcc_generic_fsm_log_mount_c, ""); +// static_assert(mcc::mcc_generic_fsm_log_mount_c, ""); } // namespace asibfm700 diff --git a/mcc/mcc_generic_mount.h b/mcc/mcc_generic_mount.h index 88a3af9..804ed87 100644 --- a/mcc/mcc_generic_mount.h +++ b/mcc/mcc_generic_mount.h @@ -39,6 +39,88 @@ class is_error_code_enum : public true_type namespace mcc { +// error category +struct MccGenericMountCategory : public std::error_category { + MccGenericMountCategory() : std::error_category() {} + + const char* name() const noexcept + { + return "MCC-GENERIC-MOUNT"; + } + + std::string message(int ec) const + { + MccGenericMountErrorCode err = static_cast(ec); + + switch (err) { + case MccGenericMountErrorCode::ERROR_OK: + return "OK"; + case MccGenericMountErrorCode::ERROR_HW_INIT: + return "an error occured while initializing mount"; + case MccGenericMountErrorCode::ERROR_HW_STOP: + return "an error occured while stopping mount"; + case MccGenericMountErrorCode::ERROR_HW_GETSTATE: + return "cannot get state of hardware"; + default: + return "UNKNOWN"; + } + } + + static const MccGenericMountCategory& get() + { + static const MccGenericMountCategory constInst; + return constInst; + } +}; + + +struct MccGenericFsmMountCategory : public std::error_category { + MccGenericFsmMountCategory() : std::error_category() {} + + const char* name() const noexcept + { + return "MCC-GENERIC-FSM-MOUNT"; + } + + std::string message(int ec) const + { + MccGenericFsmMountErrorCode err = static_cast(ec); + + switch (err) { + case MccGenericFsmMountErrorCode::ERROR_OK: + return "OK"; + case MccGenericFsmMountErrorCode::ERROR_INVALID_OPERATION: + return "requested operation is not allowed"; + case MccGenericFsmMountErrorCode::ERROR_UNKNOWN_EVENT: + return "unexpected finite-state-machine event"; + default: + return "UNKNOWN"; + } + } + + static const MccGenericFsmMountCategory& get() + { + static const MccGenericFsmMountCategory constInst; + return constInst; + } +}; + + + +inline std::error_code make_error_code(MccGenericMountErrorCode ec) +{ + return std::error_code(static_cast(ec), MccGenericMountCategory::get()); + // return std::error_code(static_cast(ec), std::generic_category()); +} + +inline std::error_code make_error_code(MccGenericFsmMountErrorCode ec) +{ + return std::error_code(static_cast(ec), MccGenericFsmMountCategory::get()); + // return std::error_code(static_cast(ec), std::generic_category()); +} + + + template -class MccGenericMountFSM : public fsm::MccFiniteStateMachine, - public MccGenericMount -{ -protected: - typedef MccGenericMount base_gmount_t; - -public: - using typename base_gmount_t::error_t; - - /* EVENTS AND STATES DEFINITION */ - - - /* base class for events */ - - struct MccGenericMountBaseEvent { - virtual ~MccGenericMountBaseEvent() = default; - - MccGenericMountFSM& mount() const - { - return _mount; - } - - protected: - MccGenericMountFSM& _mount; - - MccGenericMountBaseEvent(MccGenericMountFSM& mount) : _mount(mount) {} - }; - - // to IDLE state - struct MccGenericMountEventIDLE : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-IDLE-EVENT"; - - // CTAD does not work for clang++ (at least till v. 20 and -std=c++23)! - // so, one must explicitly define constructor here - MccGenericMountEventIDLE(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {} - }; - - - // to error state - struct MccGenericMountEventError : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-ERROR-EVENT"; - - MccGenericMountEventError(MccGenericMountFSM& mount, const error_t& err) - : MccGenericMountBaseEvent(mount), _error(err) - { - } - - - error_t eventData() const - { - return _error; - } - - protected: - error_t _error; - }; - - - // to INIT state - struct MccGenericMountEventInit : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-INIT-EVENT"; - - MccGenericMountEventInit(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {} - }; - - - // to slewing state - struct MccGenericMountEventSlew : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-SLEWING-EVENT"; - - MccGenericMountEventSlew(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {} - }; - - - // to tracking state - struct MccGenericMountEventTrack : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-TRACKING-EVENT"; - - MccGenericMountEventTrack(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {} - }; - - - // to stoping state - struct MccGenericMountEventStop : MccGenericMountBaseEvent { - static constexpr std::string_view ID = "MCC-MOUNT-STOP-EVENT"; - - MccGenericMountEventStop(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {} - }; - - - - /* base class for states */ - - struct MccGenericMountBaseState { - static constexpr std::string_view ID{"BASE-STATE"}; - - virtual ~MccGenericMountBaseState() = default; - - protected: - MccGenericMountBaseState() = default; - - template EvT> - void exitLog(this auto&& self, EvT& event) - { - using self_t = std::remove_cvref_t; - - event.mount().logDebug(std::format("Exit from '{}' state due to '{}' event ...", self_t::ID, EvT::ID)); - } - - template EvT> - void enterLog(this auto&& self, EvT& event) - { - using self_t = std::remove_cvref_t; - event.mount().logDebug(std::format("Enter to '{}' state due to '{}' event ...", self_t::ID, EvT::ID)); - } - }; - - // forward declarations - struct MccGenericMountStateInit; - struct MccGenericMountStateIDLE; - struct MccGenericMountStateError; // must be implemented in derived class - struct MccGenericMountStateSlew; - struct MccGenericMountStateTrack; - // struct MccGenericMountStateGuiding; - struct MccGenericMountStateStopping; - - struct MccGenericMountStateUninit : MccGenericMountBaseState { - static constexpr std::string_view ID{"UNINITIALIZED-STATE"}; - - // from uninitialized state only INIT-event is permitted! - using transition_t = fsm::fsm_transition_table_t>; - - template EvT> - void exit(EvT& event) - { - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - } - }; - - struct MccGenericMountStateInit : MccGenericMountBaseState { - static constexpr std::string_view ID{"INITIALIZING-STATE"}; - - using transition_t = - fsm::fsm_transition_table_t, - std::pair, - std::pair>; - - void exit(MccGenericMountEventInit& event) - { - event.mount().logWarn("It seems re-entering to initializing state was asked! Just ignore this event!"); - } - - void enter(MccGenericMountEventInit& event) - { - event.mount().logWarn( - "It seems re-entering to initializing state was asked! Ignore it and wait for mount to initialize!"); - } - - template EvT> - void exit(EvT& event) - { - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - - error_t err = event.mount()._initMount(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } else { - event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()}); - } - } - }; - - struct MccGenericMountStateIDLE : MccGenericMountBaseState { - static constexpr std::string_view ID{"IDLE-STATE"}; - - using transition_t = - fsm::fsm_transition_table_t, - std::pair, - std::pair, - std::pair, - std::pair, - std::pair>; - - template EvT> - void exit(EvT& event) - { - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - } - }; - - - struct MccGenericMountStateStopping : MccGenericMountBaseState { - static constexpr std::string_view ID{"STOPPING-STATE"}; - - using transition_t = - fsm::fsm_transition_table_t, - std::pair, - std::pair>; - - void exit(MccGenericMountEventStop& event) - { - event.mount().logWarn("It seems re-entering to stopping state was asked! Just ignore it!"); - } - - void enter(MccGenericMountEventStop& event) - { - event.mount().logWarn( - "It seems re-entering to stopping state was asked! Ignore it and wait for mount to stop!"); - } - - template EvT> - void exit(EvT& event) - { - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - - error_t err = event.mount()._stopMount(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } else { - event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()}); - } - } - }; - - - struct MccGenericMountStateSlew : MccGenericMountBaseState { - static constexpr std::string_view ID{"SLEWING-STATE"}; - - using transition_t = - fsm::fsm_transition_table_t, - std::pair, - std::pair, - std::pair, - std::pair>; - - void exit(MccGenericMountEventSlew& event) - { - event.mount().logWarn( - "It seems re-entering to slewing state was asked! Do not stop the current slewing process, just ignore " - "this event!"); - } - - void enter(MccGenericMountEventSlew& event) - { - event.mount().logWarn( - "It seems re-entering to slewing state was asked! Do not start a new slewing process, just ignore this " - "event!"); - } - - template EvT> - void exit(EvT& event) - { - error_t err = event.mount()._stopSlewingMount(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } - - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - - error_t err = event.mount()._slewMount(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } else { - auto slew_pars = event.mount().getSlewingParams(); - - if (slew_pars.slewAndStop) { - event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()}); - } else { - event.mount().dispatchEvent(MccGenericMountEventTrack{event.mount()}); - } - } - } - }; - - - struct MccGenericMountStateTrack : MccGenericMountBaseState { - static constexpr std::string_view ID{"TRACKING-STATE"}; - - using transition_t = - fsm::fsm_transition_table_t, - std::pair, - std::pair>; - - void exit(MccGenericMountEventTrack& event) - { - event.mount().logWarn( - "It seems re-entering to tracking state was asked! Do not stop the current tracking process, just " - "ignore this event!"); - } - - void enter(MccGenericMountEventTrack& event) - { - event.mount().logWarn( - "It seems re-entering to tracking state was asked! Do not start a new tracking process, just ignore " - "this event!"); - } - - template EvT> - void exit(EvT& event) - { - // error_t err = event.mount()._stopTrackingMount(); - - error_t err = static_cast(&event.mount())->stopTracking(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } - - this->exitLog(event); - } - - template EvT> - void enter(EvT& event) - { - this->enterLog(event); - - error_t err = event.mount()._trackMount(); - if (err) { - event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err}); - } - } - }; - - - using LoggerT::logDebug; - using LoggerT::logError; - using LoggerT::logInfo; - using LoggerT::logWarn; - - - using typename SlewModelT::slewing_params_t; - using typename TrackModelT::tracking_params_t; - - - /* CONSTRUCTORS AND DESTRUCTOR */ - - MccGenericMountFSM(HardwareT hardware, - TelemetryT telemetry, - PZoneContT pzone_cont, - SlewModelT slew_model, - TrackModelT track_model, - LoggerT logger = MccNullLogger{}) - : fsm::MccFiniteStateMachine(MccGenericMountStateUninit{}), - base_gmount_t(std::move(hardware), - std::move(telemetry), - std::move(pzone_cont), - std::move(slew_model), - std::move(track_model), - std::move(logger)) - { - } - - - virtual ~MccGenericMountFSM() = default; - - // reimplementation of base-class methods to adapt it to FSM-behavior - auto initMount() - { - if (_currentStateID == MccGenericMountStateInit::ID) { - logWarn("Already in initializing state! Ignore!"); - return; - } - - this->dispatchEvent(MccGenericMountEventInit{*this}); - } - - auto stopMount() - { - this->dispatchEvent(MccGenericMountEventStop{*this}); - } - - auto slewToTarget() - { - this->dispatchEvent(MccGenericMountEventSlew{*this}); - } - - auto stopSlewing() - { - this->dispatchEvent(MccGenericMountEventStop{*this}); - } - - auto trackTarget() - { - this->dispatchEvent(MccGenericMountEventTrack{*this}); - } - - - auto stopTracking() - { - this->dispatchEvent(MccGenericMountEventIDLE{*this}); - } - - -protected: - // wrappers - - auto _initMount() - { - return base_gmount_t::initMount(); - } - - - auto _stopMount() - { - return base_gmount_t::stopMount(); - } - - auto _slewToTarget() - { - return base_gmount_t::slewToTarget(); - } - - - auto _trackTarget() - { - return base_gmount_t::trackTarget(); - } - - - auto _startGuidingTarget() - { - return base_gmount_t::startGuidingTarget(); - } - - auto _stopGuidingTarget() - { - return base_gmount_t::stopGuidingTarget(); - } -}; - - } // namespace mcc diff --git a/mcc/mcc_pzone.h b/mcc/mcc_pzone.h index 9321e5a..27d050e 100644 --- a/mcc/mcc_pzone.h +++ b/mcc/mcc_pzone.h @@ -589,11 +589,7 @@ public: return MccAltLimitPZErrorCode::ERROR_OK; } - if (std::same_as) { - return err; - } else { - return MccAltLimitPZErrorCode::ERROR_COORD_TRANSFROM; - } + return mcc_deduce_error_code(err, MccAltLimitPZErrorCode::ERROR_COORD_TRANSFROM); }; _transformCoordinatesEqtHrzCoords = [controls](MccCelestialPoint from_pt, MccEqtHrzCoords* to_pt) -> error_t { @@ -617,7 +613,7 @@ public: MccPCMResult inv_res; auto err = controls->computeInversePCM(std::move(from_pt), &inv_res, to_pt); if (err) { - return mcc_deduce_error(err, MccAltLimitPZErrorCode::ERROR_PCM_COMP); + return mcc_deduce_error_code(err, MccAltLimitPZErrorCode::ERROR_PCM_COMP); } return MccAltLimitPZErrorCode::ERROR_OK; diff --git a/mcc/mcc_pzone_container.h b/mcc/mcc_pzone_container.h index aa443a3..e7b6f45 100644 --- a/mcc/mcc_pzone_container.h +++ b/mcc/mcc_pzone_container.h @@ -118,74 +118,76 @@ public: _inZoneFuncCPT.emplace_back([sptr](const MccCelestialPoint& pt, bool* res) { auto ret = sptr->inPZone(pt, res); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INZONE_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INZONE_FUNC)); }); _inZoneFuncEHC.emplace_back([sptr](const MccEqtHrzCoords& pt, bool* res) { auto ret = sptr->inPZone(pt, res); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INZONE_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INZONE_FUNC)); }); _timeToZoneFuncCPT.emplace_back([sptr](const MccCelestialPoint& pt, duration_t* res_time) { auto ret = sptr->timeToPZone(pt, res_time); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMETO_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMETO_FUNC)); }); _timeToZoneFuncEHC.emplace_back([sptr](const MccEqtHrzCoords& pt, duration_t* res_time) { auto ret = sptr->timeToPZone(pt, res_time); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMETO_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMETO_FUNC)); }); _timeFromZoneFuncCPT.emplace_back([sptr](const MccCelestialPoint& pt, duration_t* res_time) { auto ret = sptr->timeFromPZone(pt, res_time); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMEFROM_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMEFROM_FUNC)); }); _timeFromZoneFuncEHC.emplace_back([sptr](const MccEqtHrzCoords& pt, duration_t* res_time) { auto ret = sptr->timeFromPZone(pt, res_time); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMEFROM_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_TIMEFROM_FUNC)); }); // _intersectZoneFuncCPT.emplace_back([sptr](const MccCelestialPoint& pt, MccCelestialPoint* res_pt) { // auto ret = sptr->intersectPZone(pt, res_pt); - // return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + // return mcc_deduce_error_code(ret, + // mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); // }); // _intersectZoneFuncEHC.emplace_back([sptr](const MccEqtHrzCoords& pt, MccCelestialPoint* res_pt) { // auto ret = sptr->intersectPZone(pt, res_pt); - // return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + // return mcc_deduce_error_code(ret, + // mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); // }); _intersectZoneFuncCPT2CPT.emplace_back([sptr](const MccCelestialPoint& pt, MccCelestialPoint* res_pt) { auto ret = sptr->intersectPZone(pt, res_pt); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); }); _intersectZoneFuncEHC2CPT.emplace_back([sptr](const MccEqtHrzCoords& pt, MccCelestialPoint* res_pt) { auto ret = sptr->intersectPZone(pt, res_pt); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); }); _intersectZoneFuncCPT2EHC.emplace_back([sptr](const MccCelestialPoint& pt, MccEqtHrzCoords* res_pt) { auto ret = sptr->intersectPZone(pt, res_pt); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); }); _intersectZoneFuncEHC2EHC.emplace_back([sptr](const MccEqtHrzCoords& pt, MccEqtHrzCoords* res_pt) { auto ret = sptr->intersectPZone(pt, res_pt); - return mcc_deduce_error(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); + return mcc_deduce_error_code(ret, mcc::make_error_code(MccPZoneContainerErrorCode::ERROR_INTERSECT_FUNC)); }); return _inZoneFuncCPT.size(); } diff --git a/mcc/mcc_slewing_model.h b/mcc/mcc_slewing_model.h index c4719ad..528ff97 100644 --- a/mcc/mcc_slewing_model.h +++ b/mcc/mcc_slewing_model.h @@ -20,13 +20,10 @@ enum class MccSimpleSlewingModelErrorCode : int { ERROR_PCM_COMP, ERROR_GET_TELEMETRY, ERROR_DIST_TELEMETRY, - ERROR_DIFF_TELEMETRY, ERROR_PZONE_CONTAINER_COMP, ERROR_TARGET_IN_PZONE, - ERROR_IN_PZONE, ERROR_NEAR_PZONE, ERROR_TIMEOUT, - ERROR_UNEXPECTED_AXIS_RATES, ERROR_ALREADY_SLEW, ERROR_ALREADY_STOPPED, ERROR_STOPPED @@ -50,6 +47,64 @@ class is_error_code_enum : public true_type namespace mcc { +// error category +struct MccSimpleSlewingModelCategory : public std::error_category { + MccSimpleSlewingModelCategory() : std::error_category() {} + + const char* name() const noexcept + { + return "SIMPLE-TRACKING-MODEL"; + } + + std::string message(int ec) const + { + MccSimpleSlewingModelErrorCode err = static_cast(ec); + + switch (err) { + case MccSimpleSlewingModelErrorCode::ERROR_OK: + return "OK"; + case MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE: + return "cannot get hardware state"; + case MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE: + return "cannot set hardware state"; + case MccSimpleSlewingModelErrorCode::ERROR_PCM_COMP: + return "PCM computation error"; + case MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY: + return "cannot get telemetry"; + case MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY: + return "cannot get target-to-mount-position distance"; + case MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP: + return "pzone container computation error"; + case MccSimpleSlewingModelErrorCode::ERROR_TARGET_IN_PZONE: + return "target is in prohibited zone"; + case MccSimpleSlewingModelErrorCode::ERROR_NEAR_PZONE: + return "near prohibited zone"; + case MccSimpleSlewingModelErrorCode::ERROR_TIMEOUT: + return "a timeout occured while slewing"; + case MccSimpleSlewingModelErrorCode::ERROR_ALREADY_SLEW: + return "already slewing"; + case MccSimpleSlewingModelErrorCode::ERROR_ALREADY_STOPPED: + return "slewing is already stopped"; + default: + return "UNKNOWN"; + } + } + + static const MccSimpleSlewingModelCategory& get() + { + static const MccSimpleSlewingModelCategory constInst; + return constInst; + } +}; + + +inline std::error_code make_error_code(MccSimpleSlewingModelErrorCode ec) +{ + return std::error_code(static_cast(ec), MccSimpleSlewingModelCategory::get()); +} + + + /* The target celestial point must be set in telemetry->target */ @@ -77,7 +132,7 @@ public: t_err = controls->telemetryData(&tdata); if (t_err) { - return mcc_deduce_error(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY); + return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY); } } @@ -85,7 +140,7 @@ public: auto pz_err = controls->inPZone(tdata.target, &in_zone); if (pz_err) { *_stopSlewing = true; - return mcc_deduce_error(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } if (in_zone) { @@ -117,7 +172,7 @@ public: auto hw_err = controls->hardwareGetState(&hw_state); if (hw_err) { *_stopSlewing = true; - return mcc_deduce_error(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE); } hw_state.X = (double)tdata.target.X; @@ -141,7 +196,7 @@ public: hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopSlewing = true; - return mcc_deduce_error(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); } std::chrono::steady_clock::time_point start_slewing_tp, last_adjust_tp; @@ -164,7 +219,7 @@ public: if (t_err) { *_stopSlewing = true; - return mcc_deduce_error(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY); + return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_GET_TELEMETRY); } } @@ -186,8 +241,7 @@ public: pz_err = controls->inPZone(cpt, &in_zone); if (pz_err) { *_stopSlewing = true; - return mcc_deduce_error(pz_err, - MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, MccSimpleSlewingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } if (in_zone) { @@ -208,13 +262,13 @@ public: hw_err = controls->hardwareGetState(&hw_state); if (hw_err) { *_stopSlewing = true; - return mcc_deduce_error(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_GETSTATE); } t_err = controls->targetToMountDist(&dist); if (t_err) { *_stopSlewing = true; - return mcc_deduce_error(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY); + return mcc_deduce_error_code(t_err, MccSimpleSlewingModelErrorCode::ERROR_DIST_TELEMETRY); } if (*_stopSlewing) { @@ -239,8 +293,8 @@ public: hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopSlewing = true; - return mcc_deduce_error(hw_err, - MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); + return mcc_deduce_error_code(hw_err, + MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); } } } else if constexpr (mccIsAltAzMount(CONTROLS_T::mountType)) { @@ -274,7 +328,7 @@ public: hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopSlewing = true; - return mcc_deduce_error(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE); } last_adjust_tp = now; diff --git a/mcc/mcc_telemetry.h b/mcc/mcc_telemetry.h index 4245eb6..d82c3ed 100644 --- a/mcc/mcc_telemetry.h +++ b/mcc/mcc_telemetry.h @@ -143,7 +143,7 @@ public: // update apparent cordinates auto ccte_err = controls->transformCoordinates(_data.target, &_data.target); if (ccte_err) { - return mcc_deduce_error(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); + return mcc_deduce_error_code(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); } } @@ -187,7 +187,7 @@ public: // } if (pcm_err) { - return mcc_deduce_error(pcm_err, MccTelemetryErrorCode::ERROR_PCM_COMP); + return mcc_deduce_error_code(pcm_err, MccTelemetryErrorCode::ERROR_PCM_COMP); } @@ -199,7 +199,7 @@ public: typename hardware_t::hardware_state_t hw_pos; auto hw_err = controls->hardwareGetState(&hw_pos); if (hw_err) { - return mcc_deduce_error(hw_err, MccTelemetryErrorCode::ERROR_HARDWARE_GETPOS); + return mcc_deduce_error_code(hw_err, MccTelemetryErrorCode::ERROR_HARDWARE_GETPOS); } if (stop_token.stop_requested()) { @@ -228,7 +228,7 @@ public: } if (ccte_err) { - return mcc_deduce_error(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); + return mcc_deduce_error_code(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); } if (stop_token.stop_requested()) { @@ -243,7 +243,7 @@ public: // fill _data.pcmX, _data.pcmY and corresponded apparent coordinates auto pcm_err = controls->computePCM(_data, &_data, &_data); if (pcm_err) { - return mcc_deduce_error(pcm_err, MccTelemetryErrorCode::ERROR_PCM_COMP); + return mcc_deduce_error_code(pcm_err, MccTelemetryErrorCode::ERROR_PCM_COMP); } if (stop_token.stop_requested()) { @@ -311,7 +311,7 @@ public: } if (ccte_err) { - return mcc_deduce_error(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); + return mcc_deduce_error_code(ccte_err, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); } if constexpr (mccIsEquatorialMount(pcm_t::mountType)) { @@ -357,7 +357,7 @@ public: } } - return mcc_deduce_error(ret, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); + return mcc_deduce_error_code(ret, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM); }; } diff --git a/mcc/mcc_tracking_model.h b/mcc/mcc_tracking_model.h index 4f3b661..0b6bb8d 100644 --- a/mcc/mcc_tracking_model.h +++ b/mcc/mcc_tracking_model.h @@ -20,12 +20,8 @@ enum class MccSimpleTrackingModelErrorCode : int { ERROR_PCM_COMP, ERROR_GET_TELEMETRY, ERROR_DIST_TELEMETRY, - ERROR_DIFF_TELEMETRY, ERROR_PZONE_CONTAINER_COMP, - ERROR_IN_PZONE, ERROR_NEAR_PZONE, - ERROR_TIMEOUT, - ERROR_UNEXPECTED_AXIS_RATES, ERROR_ALREADY_TRACK, ERROR_ALREADY_STOPPED, ERROR_STOPPED @@ -49,6 +45,63 @@ class is_error_code_enum : public true_typ namespace mcc { + +// error category +struct MccSimpleTrackingModelCategory : public std::error_category { + MccSimpleTrackingModelCategory() : std::error_category() {} + + const char* name() const noexcept + { + return "SIMPLE-TRACKING-MODEL"; + } + + std::string message(int ec) const + { + MccSimpleTrackingModelErrorCode err = static_cast(ec); + + switch (err) { + case MccSimpleTrackingModelErrorCode::ERROR_OK: + return "OK"; + case MccSimpleTrackingModelErrorCode::ERROR_CCTE: + return "coordinate transformation error"; + case MccSimpleTrackingModelErrorCode::ERROR_HW_GETSTATE: + return "cannot get hardware state"; + case MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE: + return "cannot set hardware state"; + case MccSimpleTrackingModelErrorCode::ERROR_PCM_COMP: + return "PCM computation error"; + case MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY: + return "cannot get telemetry"; + case MccSimpleTrackingModelErrorCode::ERROR_DIST_TELEMETRY: + return "cannot get target-to-mount-position distance"; + case MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP: + return "pzone container computation error"; + case MccSimpleTrackingModelErrorCode::ERROR_NEAR_PZONE: + return "near prohibited zone"; + case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_TRACK: + return "already tracking"; + case MccSimpleTrackingModelErrorCode::ERROR_ALREADY_STOPPED: + return "tracking is already stopped"; + default: + return "UNKNOWN"; + } + } + + static const MccSimpleTrackingModelCategory& get() + { + static const MccSimpleTrackingModelCategory constInst; + return constInst; + } +}; + + +inline std::error_code make_error_code(MccSimpleTrackingModelErrorCode ec) +{ + return std::error_code(static_cast(ec), MccSimpleTrackingModelCategory::get()); +} + + + class MccSimpleTrackingModel { public: @@ -83,7 +136,7 @@ public: auto t_err = controls->telemetryData(&tdata); if (t_err) { *_stopTracking = true; - return mcc_deduce_error(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY); + return mcc_deduce_error_code(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY); } @@ -95,8 +148,7 @@ public: // compute intersection points with the prohibited zones auto pz_err = mcc_find_closest_pzone(controls, tdata, &intsc_coords); if (pz_err) { - return mcc_deduce_error(pz_err, - MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) { @@ -151,14 +203,14 @@ public: auto ret = controls->transformCoordinates(std::move(pt), point); if (ret) { - return mcc_deduce_error(ret, MccSimpleTrackingModelErrorCode::ERROR_CCTE); + return mcc_deduce_error_code(ret, MccSimpleTrackingModelErrorCode::ERROR_CCTE); } else { MccPCMResult pcm_inv_res; // endpoint of the mount moving auto pcm_err = controls->computeInversePCM(target_in_future_pt, &pcm_inv_res, &hw_state); if (pcm_err) { - return mcc_deduce_error(pcm_err, MccSimpleTrackingModelErrorCode::ERROR_PCM_COMP); + return mcc_deduce_error_code(pcm_err, MccSimpleTrackingModelErrorCode::ERROR_PCM_COMP); } mcc_tp2tp(tdata.time_point, hw_state.time_point); @@ -171,7 +223,7 @@ public: auto pz_err = update_pzones_ipoint(); if (pz_err) { *_stopTracking = true; - return mcc_deduce_error(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } hw_state.moving_state = CONTROLS_T::hardware_moving_state_t::HW_MOVE_Tracking; @@ -182,7 +234,7 @@ public: auto ccte_err = target_point(&target_in_future_pt); if (ccte_err) { *_stopTracking = true; - return mcc_deduce_error(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE); + return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE); } if constexpr (mccIsEquatorialMount(CONTROLS_T::mountType)) { @@ -195,7 +247,7 @@ public: auto hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopTracking = true; - return mcc_deduce_error(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE); } @@ -210,7 +262,7 @@ public: if (t_err) { *_stopTracking = true; - return mcc_deduce_error(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY); + return mcc_deduce_error_code(t_err, MccSimpleTrackingModelErrorCode::ERROR_GET_TELEMETRY); } } @@ -225,8 +277,7 @@ public: } if (pz_err) { *_stopTracking = true; - return mcc_deduce_error(pz_err, - MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } if (*_stopTracking) { @@ -246,8 +297,8 @@ public: pz_err = update_pzones_ipoint(); if (pz_err) { *_stopTracking = true; - return mcc_deduce_error( - pz_err, MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); + return mcc_deduce_error_code(pz_err, + MccSimpleTrackingModelErrorCode::ERROR_PZONE_CONTAINER_COMP); } } @@ -255,7 +306,7 @@ public: auto ccte_err = target_point(&target_in_future_pt); if (ccte_err) { *_stopTracking = true; - return mcc_deduce_error(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE); + return mcc_deduce_error_code(ccte_err, MccSimpleTrackingModelErrorCode::ERROR_CCTE); } } @@ -264,7 +315,7 @@ public: hw_err = controls->hardwareSetState(hw_state); if (hw_err) { *_stopTracking = true; - return mcc_deduce_error(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE); + return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE); } }