...

mcc/mcc_ccte_erfa.h

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

mcc/mcc_generic_mount.h

@@ -8,50 +8,137 @@
 
 #include "mcc_generics.h"
 
+
 namespace mcc
 {
 
-template <mcc_telemetry_c TelemetryT, mcc_pzone_container_c PZoneContT, mcc_logger_c LoggerT>
+enum class MccGenericMountErrorCode : int { ERROR_OK, ERROR_HW_STOP, ERROR_HW_GETSTATE };
-class MccGenericMount : public TelemetryT, public PZoneContT, public LoggerT
+
+}  // 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)
+    typedef std::error_code error_t;
-        : TelemetryT(std::move(telemetry)), PZoneContT(std::move(pzone_cont)), LoggerT(std::move(logger))
+
+    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;
 
-
+    error_t stopMount()
-    template <std::derived_from<MccGenericMount> SelfT>
-    auto slewToTarget(this SelfT&& self)
     {
-        return std::forward<SelfT>(self).slewToTarget();
+        logInfo("stop any movements ...");
+
+        this->stopGuidingTarget();
+        this->stopTracking();
+        this->stopSlewing();
+
+        auto hw_err = this->hardwareStop();
+        if (hw_err) {
+            return mcc_deduce_error(hw_err, MccGenericMountErrorCode::ERROR_HW_STOP);
         }
 
-    template <std::derived_from<MccGenericMount> SelfT>
+        // poll hardware till stopped-state detected ...
-    auto trackTarget(this SelfT&& self)
-    {
-        return std::forward<SelfT>(self).trackTarget();
-    }
 
-    template <std::derived_from<MccGenericMount> SelfT>
+        logInfo("mount was stopped");
-    auto startGuidingTarget(this SelfT&& self)
-    {
-        return std::forward<SelfT>(self).startGuidingTarget();
-    }
 
-    template <std::derived_from<MccGenericMount> SelfT>
+        return MccGenericMountErrorCode::ERROR_OK;
-    auto stopGuidingTarget(this SelfT&& self)
-    {
-        return std::forward<SelfT>(self).stopGuidingTarget();
-    }
-
-    template <std::derived_from<MccGenericMount> SelfT>
-    auto stopMount(this SelfT&& self)
-    {
-        return std::forward<SelfT>(self).stopMount();
     }
 };
 
+
+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

mcc/mcc_generics.h

@@ -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
+    // a type that defines at least HW_MOVE_STOPPED, HW_MOVE_SLEWING, HW_MOVE_ADJUSTING, HW_MOVE_TRACKING
-    requires requires(typename T::axes_pos_t pos) {
+    // and HW_MOVE_GUIDING compile-time constants. The main purpose of this type is a
-        requires mcc_time_point_c<decltype(pos.time_point)>;  // time point
+    // 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
+            // hardware was asked for slewing (move to given celestial point)
-        requires mcc_angle_c<decltype(pos.Y)>;  // target or current co-latitude coordinate
+            static constexpr auto v1 = T::hardware_moving_state_t::HW_MOVE_SLEWING;
 
-        requires mcc_angle_c<decltype(pos.speedX)>;
+            // hardware was asked for adjusting after slewing
-        requires mcc_angle_c<decltype(pos.speedY)>;
+            // (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
+    // get current state
-    { t.getPos(std::declval<typename T::axes_pos_t*>()) } -> std::same_as<typename T::error_t>;
+    { 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.hardwareStop() } -> std::same_as<typename T::error_t>;  // stop any moving
-    { t.init() } -> std::same_as<typename T::error_t>;  // initialize hardware
+    { 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>;
 };
 
 

mcc/mcc_telemetry.h

@@ -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;
+            typename hardware_t::hardware_state_t hw_pos;
-            auto hw_err = hardware->getPos(&hw_pos);
+            auto hw_err = hardware->hardwareGetState(&hw_pos);
             if (hw_err) {
                 return mcc_deduce_error(hw_err, MccTelemetryErrorCode::ERROR_HARDWARE_GETPOS);
             }