...

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>
-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