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
Download Patch File Download Diff File Expand all files Collapse all files

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