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-08-26 19:56:32 +03:00
parent 7556539084
commit 052d4e2eb4
4 changed files with 185 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
mcc/mcc_ccte_erfa.h
View File

@ -123,7 +123,6 @@ inline std::error_code make_error_code(MccCCTE_ERFAErrorCode ec)
}
class MccCCTE_ERFA : public mcc_CCTE_interface_t<std::error_code>
{
static constexpr double PI_2 = std::numbers::pi / 2.0;
@ -183,28 +182,28 @@ public:
virtual ~MccCCTE_ERFA() = default;
std::string_view name() const
std::string_view nameCCTE() const
{
return "ERFA-CCTE-ENGINE";
}
// engine state related methods
void setState(engine_state_t state)
void setStateERFA(engine_state_t state)
{
std::lock_guard lock{*_stateMutex};
_currentState = std::move(state);
}
engine_state_t getState() const
engine_state_t getStateERFA() const
{
std::lock_guard lock{*_stateMutex};
return _currentState;
}
void updateMeteo(meteo_t meteo)
void updateMeteoERFA(meteo_t meteo)
{
std::lock_guard lock{*_stateMutex};

143
mcc/mcc_generic_mount.h
View File

@ -8,50 +8,137 @@
#include "mcc_generics.h"
namespace mcc
{
template <mcc_telemetry_c TelemetryT, mcc_pzone_container_c PZoneContT, mcc_logger_c LoggerT>
class MccGenericMount : public TelemetryT, public PZoneContT, public LoggerT
enum class MccGenericMountErrorCode : int { ERROR_OK, ERROR_HW_STOP, ERROR_HW_GETSTATE };
} // namespace mcc
namespace std
{
template <>
class is_error_code_enum<mcc::MccGenericMountErrorCode> : public true_type
{
};
} // namespace std
namespace mcc
{
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_guiding_model_c GuidingModelT,
mcc_logger_c LoggerT = MccNullLogger>
class MccGenericMount : public HardwareT,
public TelemetryT,
public PZoneContT,
public SlewModelT,
public TrackModelT,
public GuidingModelT,
public LoggerT
{
public:
MccGenericMount(TelemetryT telemetry, PZoneContT pzone_cont, LoggerT logger)
: TelemetryT(std::move(telemetry)), PZoneContT(std::move(pzone_cont)), LoggerT(std::move(logger))
typedef std::error_code error_t;
using LoggerT::logDebug;
using LoggerT::logError;
using LoggerT::logInfo;
using LoggerT::logWarn;
using typename GuidingModelT::guiding_params_t;
using typename SlewModelT::slewing_params_t;
using typename TrackModelT::tracking_params_t;
MccGenericMount(HardwareT hardware,
TelemetryT telemetry,
PZoneContT pzone_cont,
SlewModelT slew_model,
TrackModelT track_model,
GuidingModelT guiding_model,
LoggerT logger = MccNullLogger{})
: HardwareT(std::move(hardware)),
TelemetryT(std::move(telemetry)),
PZoneContT(std::move(pzone_cont)),
SlewModelT(std::move(slew_model)),
TrackModelT(std::move(track_model)),
GuidingModelT(std::move(guiding_model)),
LoggerT(std::move(logger))
{
}
virtual ~MccGenericMount() = default;
template <std::derived_from<MccGenericMount> SelfT>
auto slewToTarget(this SelfT&& self)
error_t stopMount()
{
return std::forward<SelfT>(self).slewToTarget();
}
logInfo("stop any movements ...");
template <std::derived_from<MccGenericMount> SelfT>
auto trackTarget(this SelfT&& self)
{
return std::forward<SelfT>(self).trackTarget();
}
this->stopGuidingTarget();
this->stopTracking();
this->stopSlewing();
template <std::derived_from<MccGenericMount> SelfT>
auto startGuidingTarget(this SelfT&& self)
{
return std::forward<SelfT>(self).startGuidingTarget();
}
auto hw_err = this->hardwareStop();
if (hw_err) {
return mcc_deduce_error(hw_err, MccGenericMountErrorCode::ERROR_HW_STOP);
}
template <std::derived_from<MccGenericMount> SelfT>
auto stopGuidingTarget(this SelfT&& self)
{
return std::forward<SelfT>(self).stopGuidingTarget();
}
// poll hardware till stopped-state detected ...
template <std::derived_from<MccGenericMount> SelfT>
auto stopMount(this SelfT&& self)
{
return std::forward<SelfT>(self).stopMount();
logInfo("mount was stopped");
return MccGenericMountErrorCode::ERROR_OK;
}
};
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_guiding_model_c GuidingModelT,
mcc_logger_c LoggerT = MccNullLogger>
class MccGenericMountFSM
: public fsm::MccFiniteStateMachine,
protected MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, GuidingModelT, LoggerT>
{
protected:
typedef MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, GuidingModelT, LoggerT>
base_gmount_t;
public:
struct MccGenericMountStateUninit {
using transition_t = fsm::fsm_transition_table_t<>;
};
MccGenericMountFSM(HardwareT hardware,
TelemetryT telemetry,
PZoneContT pzone_cont,
SlewModelT slew_model,
TrackModelT track_model,
GuidingModelT guiding_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(guiding_model),
std::move(logger))
{
}
};
} // namespace mcc

91
mcc/mcc_generics.h
View File

@ -314,7 +314,7 @@ protected:
template <typename T>
concept mcc_ccte_c = std::derived_from<T, mcc_CCTE_interface_t<typename T::error_t>> && requires(const T t_const, T t) {
{ t_const.name() } -> std::formattable<char>;
{ t_const.nameCCTE() } -> std::formattable<char>;
requires mcc_refract_model_c<typename T::refract_model_t>;
@ -532,31 +532,73 @@ concept mcc_PCM_c =
template <typename T>
concept mcc_hardware_c = requires(T t, const T t_const) {
typename T::error_t;
requires mcc_error_c<typename T::error_t>;
{ t_const.name() } -> std::formattable<char>;
{ t_const.hardwareName() } -> std::formattable<char>;
// a class that contains at least time point of measurement, coordinates for x,y axes and its moving rates
requires requires(typename T::axes_pos_t pos) {
requires mcc_time_point_c<decltype(pos.time_point)>; // time point
// a type that defines at least HW_MOVE_STOPPED, HW_MOVE_SLEWING, HW_MOVE_ADJUSTING, HW_MOVE_TRACKING
// and HW_MOVE_GUIDING compile-time constants. The main purpose of this type is a
// possible tunning of hardware hardwareSetState-related commands and detect stop-state
//
// e.g. an implementations can be as follows:
// enum class hardware_moving_state_t: int {HW_MOVE_STOPPED, HW_MOVE_SLEWING, HW_MOVE_ADJUSTING,
// HW_MOVE_TRACKING, HW_MOVE_GUIDING}
//
// struct hardware_moving_state_t {
// uint16_t HW_MOVE_STOPPED = 0;
// uint16_t HW_MOVE_SLEWING = 111;
// uint16_t HW_MOVE_ADJUSTING = 222;
// uint16_t HW_MOVE_TRACKING = 333;
// uint16_t HW_MOVE_GUIDING = 444;
// }
requires requires(typename T::hardware_moving_state_t type) {
[]() {
// mount axes were stopped
static constexpr auto v0 = T::hardware_moving_state_t::HW_MOVE_STOPPED;
requires mcc_angle_c<decltype(pos.X)>; // target or current co-longitude coordinate
requires mcc_angle_c<decltype(pos.Y)>; // target or current co-latitude coordinate
// hardware was asked for slewing (move to given celestial point)
static constexpr auto v1 = T::hardware_moving_state_t::HW_MOVE_SLEWING;
requires mcc_angle_c<decltype(pos.speedX)>;
requires mcc_angle_c<decltype(pos.speedY)>;
// hardware was asked for adjusting after slewing
// (adjusting actual mount position to align with target celestial point at the end of slewing process)
static constexpr auto v2 = T::hardware_moving_state_t::HW_MOVE_ADJUSTING;
// hardware was asked for tracking (track target celestial point)
static constexpr auto v3 = T::hardware_moving_state_t::HW_MOVE_TRACKING;
// hardware was asked for guiding
// (small corrections to align actual mount position with target celestial point)
static constexpr auto v4 = T::hardware_moving_state_t::HW_MOVE_GUIDING;
}();
};
// set positions (angles) of mount axes with given speeds
// a class that contains at least time point of measurement, coordinates for x,y axes, its moving rates and moving
// type
requires requires(typename T::hardware_state_t state) {
requires mcc_time_point_c<decltype(state.time_point)>; // time point
requires mcc_angle_c<decltype(state.X)>; // target or current co-longitude coordinate
requires mcc_angle_c<decltype(state.Y)>; // target or current co-latitude coordinate
requires mcc_angle_c<decltype(state.speedX)>; // moving speed along co-longitude coordinate
requires mcc_angle_c<decltype(state.speedY)>; // moving speed along co-latitude coordinate
std::same_as<typename T::hardware_moving_state_t, decltype(state.moving_type)>;
};
// set hardware state:
// i.g. set positions (angles) of mount axes with given speeds
// NOTE: exact interpretation (or even ignoring) of the given moving speeds is subject of a hardware-class
// implementation, e.g. it can be maximal speeds at slewing ramp
{ t.setPos(std::declval<typename T::axes_pos_t>()) } -> std::same_as<typename T::error_t>;
{ t.hardwareSetState(std::declval<typename T::hardware_state_t>()) } -> std::same_as<typename T::error_t>;
// get current positions and speeds (angles) of mount axes
{ t.getPos(std::declval<typename T::axes_pos_t*>()) } -> std::same_as<typename T::error_t>;
// get current state
{ t.hardwareGetState(std::declval<typename T::hardware_state_t*>()) } -> std::same_as<typename T::error_t>;
{ t.stop() } -> std::same_as<typename T::error_t>; // stop any moving
{ t.init() } -> std::same_as<typename T::error_t>; // initialize hardware
{ t.hardwareStop() } -> std::same_as<typename T::error_t>; // stop any moving
{ t.hardwareInit() } -> std::same_as<typename T::error_t>; // initialize hardware
};
@ -684,8 +726,10 @@ template <typename T>
concept mcc_pzone_container_c = std::derived_from<T, mcc_pzone_container_interface_t<typename T::error_t>>;
/* MOUNT MOVING MODEL CONCEPT */
template <typename T>
concept mcc_slewing_model_c = requires(T t, const T t_const) {
concept mcc_slewing_model_c = requires(T t) {
requires mcc_error_c<typename T::error_t>;
// a class of slewing process parameters
@ -694,8 +738,6 @@ concept mcc_slewing_model_c = requires(T t, const T t_const) {
std::convertible_to<decltype(pars.slewAndStop), bool>;
};
{ t_const.name() } -> std::formattable<char>;
{ t.slewToTarget() } -> std::same_as<typename T::error_t>;
{ t.stopSlewing() } -> std::same_as<typename T::error_t>;
@ -705,7 +747,7 @@ concept mcc_slewing_model_c = requires(T t, const T t_const) {
template <typename T>
concept mcc_tracking_model_c = requires(T t, const T t_const) {
concept mcc_tracking_model_c = requires(T t) {
requires mcc_error_c<typename T::error_t>;
// a class of tracking process parameters
@ -714,8 +756,6 @@ concept mcc_tracking_model_c = requires(T t, const T t_const) {
requires mcc_angle_c<decltype(pars.trackSpeedY)>;
};
{ t_const.name() } -> std::formattable<char>;
{ t.trackTarget() } -> std::same_as<typename T::error_t>;
{ t.stopTracking() } -> std::same_as<typename T::error_t>;
@ -724,7 +764,7 @@ concept mcc_tracking_model_c = requires(T t, const T t_const) {
};
template <typename T>
concept mcc_guiding_model_c = requires(T t, const T t_const) {
concept mcc_guiding_model_c = requires(T t) {
requires mcc_error_c<typename T::error_t>;
// a class of guiding process parameters
@ -733,8 +773,6 @@ concept mcc_guiding_model_c = requires(T t, const T t_const) {
std::convertible_to<decltype(pars.dualAxisGuiding), bool>;
};
{ t_const.name() } -> std::formattable<char>;
{ t.startGuidingTarget() } -> std::same_as<typename T::error_t>;
{ t.stopGuidingTarget() } -> std::same_as<typename T::error_t>;
@ -796,7 +834,6 @@ concept mcc_guiding_model_c = requires(T t, const T t_const) {
template <typename T>
concept mcc_generic_mount_c = mcc_telemetry_c<T> && mcc_pzone_container_c<T> && requires(T t) {
requires mcc_error_c<typename T::error_t>;
typename T::stop_reason_t;
// slew mount to target (target coordinates were defined in telemetry data)
{ t.slewToTarget() } -> std::same_as<typename T::error_t>;
@ -809,7 +846,7 @@ concept mcc_generic_mount_c = mcc_telemetry_c<T> && mcc_pzone_container_c<T> &&
{ t.stopGuidingTarget() } -> std::same_as<typename T::error_t>;
// stop any movement
{ t.stopMount(std::declval<typename T::stop_reason_t>()) } -> std::same_as<typename T::error_t>;
{ t.stopMount() } -> std::same_as<typename T::error_t>;
};

4
mcc/mcc_telemetry.h
View File

@ -201,8 +201,8 @@ public:
_updateFunc = [ccte, pcm, hardware, this](std::stop_token stop_token) {
// first, update mount quantities
typename hardware_t::axes_pos_t hw_pos;
auto hw_err = hardware->getPos(&hw_pos);
typename hardware_t::hardware_state_t hw_pos;
auto hw_err = hardware->hardwareGetState(&hw_pos);
if (hw_err) {
return mcc_deduce_error(hw_err, MccTelemetryErrorCode::ERROR_HARDWARE_GETPOS);
}