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-09-17 12:51:28 +03:00
parent 4e3a50acba
commit 281ceacf89
8 changed files with 259 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
asibfm700/asibfm700_mount.cpp
View File

@ -4,36 +4,10 @@ namespace asibfm700
{
Asibfm700Mount::Asibfm700Mount(Asibfm700MountConfig const& config,
std::shared_ptr<spdlog::logger> 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<spdlog::logger> 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());
}

62
asibfm700/asibfm700_mount.h
View File

@ -17,52 +17,16 @@
namespace asibfm700
{
class Asibfm700Mount : public mcc::ccte::erfa::MccCCTE_ERFA,
public mcc::MccDefaultPCM<asibfm700MountType>,
public mcc::MccGenericMountFSM<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
{
typedef mcc::MccGenericMountFSM<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>
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<spdlog::logger> logger,
const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT);
~Asibfm700Mount();
};
class Asibfm700Mount1 : public mcc::ccte::erfa::MccCCTE_ERFA,
public mcc::MccDefaultPCM<asibfm700MountType>,
public mcc::MccGenericFsmMount<mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>>
public mcc::MccGenericFsmMount<mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
Asibfm700PZoneContainer,
mcc::MccSimpleSlewingModel,
mcc::MccSimpleTrackingModel,
Asibfm700Logger>>
{
typedef mcc::MccGenericMount<AsibFM700ServoController,
mcc::MccTelemetry,
@ -129,17 +93,17 @@ public:
using Asibfm700Logger::logInfo;
using Asibfm700Logger::logWarn;
Asibfm700Mount1(Asibfm700MountConfig const& config,
std::shared_ptr<spdlog::logger> logger,
const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT);
Asibfm700Mount(Asibfm700MountConfig const& config,
std::shared_ptr<spdlog::logger> logger,
const auto& pattern_range = mcc::utils::MccSpdlogLogger::LOGGER_DEFAULT_FORMAT);
~Asibfm700Mount1();
~Asibfm700Mount();
};
static_assert(mcc::mcc_position_controls_c<Asibfm700Mount>, "");
static_assert(mcc::mcc_all_controls_c<Asibfm700Mount>, "");
static_assert(mcc::mcc_generic_mount_c<Asibfm700Mount>, "");
static_assert(mcc::mcc_generic_fsm_log_mount_c<Asibfm700Mount>, "");
// static_assert(mcc::mcc_generic_fsm_log_mount_c<Asibfm700Mount>, "");
} // namespace asibfm700

548
mcc/mcc_generic_mount.h
View File

@ -39,6 +39,88 @@ class is_error_code_enum<mcc::MccGenericFsmMountErrorCode> : 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<MccGenericMountErrorCode>(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<MccGenericFsmMountErrorCode>(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<int>(ec), MccGenericMountCategory::get());
// return std::error_code(static_cast<int>(ec), std::generic_category());
}
inline std::error_code make_error_code(MccGenericFsmMountErrorCode ec)
{
return std::error_code(static_cast<int>(ec), MccGenericFsmMountCategory::get());
// return std::error_code(static_cast<int>(ec), std::generic_category());
}
template <mcc_hardware_c HardwareT,
mcc_telemetry_c TelemetryT,
mcc_pzone_container_c PZoneContT,
@ -663,470 +745,4 @@ public:
};
template <mcc_hardware_c HardwareT,
mcc_telemetry_c TelemetryT,
mcc_pzone_container_c PZoneContT,
mcc_slewing_model_c SlewModelT,
mcc_tracking_model_c TrackModelT,
mcc_logger_c LoggerT = MccNullLogger>
class MccGenericMountFSM : public fsm::MccFiniteStateMachine,
public MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, LoggerT>
{
protected:
typedef MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, LoggerT> 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 <std::derived_from<MccGenericMountBaseEvent> EvT>
void exitLog(this auto&& self, EvT& event)
{
using self_t = std::remove_cvref_t<decltype(self)>;
event.mount().logDebug(std::format("Exit from '{}' state due to '{}' event ...", self_t::ID, EvT::ID));
}
template <std::derived_from<MccGenericMountBaseEvent> EvT>
void enterLog(this auto&& self, EvT& event)
{
using self_t = std::remove_cvref_t<decltype(self)>;
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<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>>;
template <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
std::pair<MccGenericMountEventError, MccGenericMountStateError>,
std::pair<MccGenericMountEventInit, MccGenericMountStateInit>>;
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 <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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<MccGenericMountEventInit, MccGenericMountStateInit>,
std::pair<MccGenericMountEventError, MccGenericMountStateError>,
std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
std::pair<MccGenericMountEventSlew, MccGenericMountStateSlew>,
std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>,
std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>>;
template <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
std::pair<MccGenericMountEventError, MccGenericMountStateError>,
std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>>;
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 <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
std::pair<MccGenericMountEventError, MccGenericMountStateError>,
std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>,
std::pair<MccGenericMountEventSlew, MccGenericMountStateSlew>>;
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 <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
error_t err = event.mount()._stopSlewingMount();
if (err) {
event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
}
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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<MccGenericMountEventStop, MccGenericMountStateStopping>,
std::pair<MccGenericMountEventError, MccGenericMountStateError>,
std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;
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 <std::derived_from<MccGenericMountBaseEvent> EvT>
void exit(EvT& event)
{
// error_t err = event.mount()._stopTrackingMount();
error_t err = static_cast<SlewModelT*>(&event.mount())->stopTracking();
if (err) {
event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
}
this->exitLog(event);
}
template <std::derived_from<MccGenericMountBaseEvent> 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

8
mcc/mcc_pzone.h
View File

@ -589,11 +589,7 @@ public:
return MccAltLimitPZErrorCode::ERROR_OK;
}
if (std::same_as<decltype(err), error_t>) {
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<error_t>(err, MccAltLimitPZErrorCode::ERROR_PCM_COMP);
return mcc_deduce_error_code(err, MccAltLimitPZErrorCode::ERROR_PCM_COMP);
}
return MccAltLimitPZErrorCode::ERROR_OK;

26
mcc/mcc_pzone_container.h
View File

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

84
mcc/mcc_slewing_model.h
View File

@ -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<mcc::MccSimpleSlewingModelErrorCode> : 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<MccSimpleSlewingModelErrorCode>(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<int>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
return mcc_deduce_error_code(hw_err, MccSimpleSlewingModelErrorCode::ERROR_HW_SETSTATE);
}
last_adjust_tp = now;

14
mcc/mcc_telemetry.h
View File

@ -143,7 +143,7 @@ public:
// update apparent cordinates
auto ccte_err = controls->transformCoordinates(_data.target, &_data.target);
if (ccte_err) {
return mcc_deduce_error<error_t>(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<error_t>(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<error_t>(ret, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM);
return mcc_deduce_error_code(ret, MccTelemetryErrorCode::ERROR_COORD_TRANSFORM);
};
}

89
mcc/mcc_tracking_model.h
View File

@ -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<mcc::MccSimpleTrackingModelErrorCode> : 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<MccSimpleTrackingModelErrorCode>(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<int>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(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<error_t>(
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<error_t>(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
return mcc_deduce_error_code(hw_err, MccSimpleTrackingModelErrorCode::ERROR_HW_SETSTATE);
}
}