...

cxx/CMakeLists.txt

@@ -137,7 +137,9 @@ target_include_directories(${MCC_LIBRARY} INTERFACE ${FITPACK_INCLUDE_DIR})
 
 set(ASIBFM700_LIB_SRC asibfm700_common.h asibfm700_hardware.h asibfm700_hardware.cpp)
 set(ASIBFM700_LIB asibfm700)
-add_library(${ASIBFM700_LIB} STATIC ${ASIBFM700_LIB_SRC})
+add_library(${ASIBFM700_LIB} STATIC ${ASIBFM700_LIB_SRC}
+    asibfm700_mount.h asibfm700_mount.cpp
+    asibfm700_config.h)
 target_include_directories(${ASIBFM700_LIB} PRIVATE ${FITPACK_INCLUDE_DIR})
 
 # set(MOUNT_SERVER_APP_SRC mount.h mount_state.h mount_server.cpp comm_server.h comm_server_endpoint.h comm_server_configfile.h mount_astrom.h

cxx/asibfm700_common.h

@@ -6,13 +6,14 @@
 
 
 #include "asibfm700_hardware.h"
-#include "mcc_fsm_mount.h"
+// #include "mcc_fsm_mount.h"
 #include "mcc_guiding_model.h"
 #include "mcc_mount_astro_erfa.h"
 #include "mcc_mount_pec.h"
 #include "mcc_mount_pz.h"
 #include "mcc_mount_telemetry.h"
 #include "mcc_slew_model.h"
+// #include "mcc_spdlog.h"
 
 namespace asibfm700
 {
@@ -33,8 +34,8 @@ static_assert(std::movable<AsibFM700Telemetry>);
 static_assert(std::movable<AsibFM700AstromEngine>);
 static_assert(std::movable<mcc::MccAltLimitPZ<>>);
 
-// typedef mcc::MccSimpleSlewModel<> AsibFM700SlewModel;
+// typedef mcc::MccSimpleSlewModel<mcc::utils::MccSpdlogLogger> AsibFM700SlewModel;
-// typedef mcc::MccSimpleGuidingModel<> AsibFM700GuidingModel;
+// typedef mcc::MccSimpleGuidingModel<mcc::utils::MccSpdlogLogger> AsibFM700GuidingModel;
 
 
 template <mcc::traits::mcc_logger_c LoggerT>
@@ -43,6 +44,7 @@ using AsibFM700SlewModel = mcc::MccSimpleSlewModel<LoggerT>;
 template <mcc::traits::mcc_logger_c LoggerT>
 using AsibFM700GuidingModel = mcc::MccSimpleGuidingModel<LoggerT>;
 
+/*
 
 template <mcc::traits::mcc_logger_c LoggerT>
 struct AsibFM700MountControls {
@@ -65,12 +67,6 @@ static_assert(mcc::traits::mcc_mount_controls_c<AsibFM700MountControls<mcc::util
 
 // global mount configuration
 
-struct AsibFM700Config {
-    std::chrono::milliseconds hardwarePollingPeriod{100};  // main cycle period
-
-    // mount hardware config
-    AsibFM700Hardware::hardware_config_t hardwareConfig;
-};
 
 
 class AsibFM700Mount : public mcc::MccMount<AsibFM700MountControls<mcc::utils::MccSpdlogLogger>>
@@ -81,5 +77,5 @@ class AsibFM700Mount : public mcc::MccMount<AsibFM700MountControls<mcc::utils::M
 
 public:
 };
-
+*/
 }  // namespace asibfm700

cxx/asibfm700_config.h

@@ -0,0 +1,34 @@
+#pragma once
+
+
+/*                          AstroSIB-FM700 FORK MOUNT CONTROL LIBRARY                           */
+
+
+/*                          MOUNT CONFIGURATION DEFINITION                                      */
+
+#include "asibfm700_common.h"
+
+namespace asibfm700
+{
+
+struct AsibFM700Config {
+    std::chrono::milliseconds hardwarePollingPeriod{100};  // main cycle period
+
+    // mount hardware config
+    AsibFM700Hardware::hardware_config_t hardwareConfig;
+
+    // astrometry engine
+    AsibFM700AstromEngine::engine_state_t astromEngineState;
+    std::string leapSecondFilename;
+    std::string bulletinAFilename;
+
+    // PEC
+    AsibFM700PointingErrorCorrection::pec_data_t pecData;
+
+    // slew and guiding
+    mcc::MccSlewAndGuidingPoint::slew_guiding_params_t slewGuidingParams;
+};
+
+
+
+}  // namespace asibfm700

cxx/asibfm700_hardware.h

@@ -118,8 +118,6 @@ public:
 private:
     hardware_config_t _hardwareConfig;
 
-    std::jthread _statePollingThread;
-
     double _sideralRate2;  // square of sideral rate
     double _sideralRateEps2;
 };

cxx/asibfm700_mount.cpp

@@ -0,0 +1,20 @@
+#include "asibfm700_mount.h"
+
+namespace asibfm700
+{
+
+template <mcc::traits::mcc_range_of_input_char_range R>
+AsibFM700Mount::AsibFM700Mount(AsibFM700Config config, std::shared_ptr<spdlog::logger> logger, const R& pattern_range)
+    : mcc::utils::MccSpdlogLogger(std::move(logger), pattern_range),
+      _currentConfig(std::move(config)),
+      base_gm_t(std::make_tuple(_currentConfig.astromEngineState),
+                std::make_tuple(_currentConfig.hardwareConfig),
+                std::make_tuple(_currentConfig.pecData),
+                std::make_tuple(std::ref(_astromEngine), std::ref(_pec), std::ref(_hardware)),
+                std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)),
+                std::make_tuple(std::ref(_telemetry), std::ref(_hardware), std::ref(_pzFuncs)))
+{
+}
+
+
+}  // namespace asibfm700

cxx/asibfm700_mount.h

@@ -0,0 +1,45 @@
+#pragma once
+
+/*                          AstroSIB-FM700 FORK MOUNT CONTROL LIBRARY                           */
+
+
+#include "asibfm700_common.h"
+#include "asibfm700_config.h"
+
+#include "mcc_generic_mount.h"
+#include "mcc_spdlog.h"
+
+namespace asibfm700
+{
+
+
+class AsibFM700Mount : public mcc::utils::MccSpdlogLogger,
+                       public mcc::MccGenericMount<AsibFM700AstromEngine,
+                                                   AsibFM700Hardware,
+                                                   AsibFM700PointingErrorCorrection,
+                                                   AsibFM700Telemetry,
+                                                   AsibFM700SlewModel<mcc::utils::MccSpdlogLogger>,
+                                                   AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger>>
+{
+    using base_gm_t = mcc::MccGenericMount<AsibFM700AstromEngine,
+                                           AsibFM700Hardware,
+                                           AsibFM700PointingErrorCorrection,
+                                           AsibFM700Telemetry,
+                                           AsibFM700SlewModel<mcc::utils::MccSpdlogLogger>,
+                                           AsibFM700GuidingModel<mcc::utils::MccSpdlogLogger>>;
+
+public:
+    template <mcc::traits::mcc_range_of_input_char_range R = decltype(LOGGER_DEFAULT_FORMAT)>
+    AsibFM700Mount(AsibFM700Config config,
+                   std::shared_ptr<spdlog::logger> logger,
+                   const R& pattern_range = LOGGER_DEFAULT_FORMAT);
+
+    ~AsibFM700Mount();
+
+
+private:
+    AsibFM700Config _currentConfig;
+};
+
+
+}  // namespace asibfm700

cxx/mcc_generic_mount.h

@@ -40,29 +40,43 @@ template <traits::mcc_astrom_engine_c ASTROM_ENGINE_T,
           traits::mcc_mount_pec_c PEC_T,
           traits::mcc_mount_telemetry_c TELEMETRY_T,
           traits::mcc_slew_model_c SLEWMODEL_T,
-          traits::mcc_guiding_model_c GUIDEMODEL_T,
+          traits::mcc_guiding_model_c GUIDINGMODEL_T>
-          traits::mcc_logger_c LOGGER_T>
+class MccGenericMount
-class MccGenericMount : public LOGGER_T
 {
-    typedef LOGGER_T logger_t;
+public:
-
-    using logger_t::logDebug;
-    using logger_t::logError;
-    using logger_t::logInfo;
-    using logger_t::logWarn;
-
     typedef ASTROM_ENGINE_T astrom_engine_t;
     typedef HARDWARE_T hardware_t;
     typedef PEC_T pec_t;
     typedef TELEMETRY_T telemetry_t;
-    typedef typename TELEMETRY_T::telemetry_data_t telemetry_data_t;
+    typedef typename TELEMETRY_T::mount_telemetry_data_t telemetry_data_t;
     typedef SLEWMODEL_T slew_model_t;
-    typedef GUIDEMODEL_T guiding_model_t;
+    typedef GUIDINGMODEL_T guiding_model_t;
 
     typedef typename MccPZoneWrapper<telemetry_data_t>::duration_t pz_duration_t;
 
     static constexpr MccMountType mountType = pec_t::mountType;
 
+    template <traits::mcc_tuple_c ASTROM_ENGINE_CTOR_T,
+              traits::mcc_tuple_c HARDWARE_CTOR_T,
+              traits::mcc_tuple_c PEC_CTOR_T,
+              traits::mcc_tuple_c TELEMETRY_CTOR_T,
+              traits::mcc_tuple_c SLEWMODEL_CTOR_T,
+              traits::mcc_tuple_c GUIDINGMODEL_CTOR_T>
+    MccGenericMount(ASTROM_ENGINE_CTOR_T aengine_ctor_args,
+                    HARDWARE_CTOR_T hw_ctor_args,
+                    PEC_CTOR_T pec_ctor_args,
+                    TELEMETRY_CTOR_T t_ctor_args,
+                    SLEWMODEL_CTOR_T smodel_ctor_args,
+                    GUIDINGMODEL_CTOR_T gmodel_ctor_args)
+        : _astromEngine(std::make_from_tuple<ASTROM_ENGINE_T>(std::move(aengine_ctor_args))),
+          _hardware(std::make_from_tuple<HARDWARE_T>(std::move(hw_ctor_args))),
+          _pec(std::make_from_tuple<PEC_T>(std::move(pec_ctor_args))),
+          _telemetry(std::make_from_tuple<TELEMETRY_T>(std::move(t_ctor_args))),
+          _slewModel(std::make_from_tuple<SLEWMODEL_T>(std::move(smodel_ctor_args))),
+          _guidingModel(std::make_from_tuple<GUIDINGMODEL_T>(std::move(gmodel_ctor_args)))
+    {
+    }
+
     virtual ~MccGenericMount() = default;
 
     // get telemetry data
@@ -227,7 +241,7 @@ protected:
     PEC_T _pec;
     TELEMETRY_T _telemetry;
     SLEWMODEL_T _slewModel;
-    GUIDEMODEL_T _gudingModel;
+    GUIDINGMODEL_T _guidingModel;
 
     std::vector<MccPZoneWrapper<telemetry_data_t>> _pzFuncs{};
 };

cxx/mcc_guiding_model.h

@@ -96,31 +96,6 @@ inline std::error_code make_error_code(MccSimpleGuidingModelErrorCode ec)
 
 
 
-/*                  */
-
-class MccCelestialPointTrack final
-{
-public:
-    template <traits::mcc_astrom_engine_c ASTROM_ENGINE_T, traits::mcc_time_duration_c DT>
-    MccCelestialPointTrack(ASTROM_ENGINE_T& astrom_engine,
-                           typename ASTROM_ENGINE_T::juldate_t start,
-                           DT step,
-                           size_t Npoints)
-    {
-        const auto p_astrom_engine = &astrom_engine;
-
-        _compFunc = []() {
-
-        };
-    }
-
-private:
-    std::function<size_t()> _compFunc;
-};
-
-/*                  */
-
-
 template <traits::mcc_logger_c LoggerT = MccNullLogger>
 class MccSimpleGuidingModel : public LoggerT
 {

cxx/mcc_slew_guiding_model_common.h

@@ -27,7 +27,8 @@ static_assert(traits::mcc_celestial_point_c<MccCelestialPoint>, "MccCelestialPoi
 
 /*  COMMON SLEW-AND-GUIDING POINT CLASS DEFINITION  */
 
-struct MccSlewAndGuidingPoint : MccCelestialPoint {
+template <typename coord_t>
+struct MccSimpleSlewAndGuidingModelParams {
     // ******* default constants *******
 
     static constexpr size_t defaultWithinToleranceCycleNumber = 10;
@@ -74,6 +75,11 @@ struct MccSlewAndGuidingPoint : MccCelestialPoint {
     bool dualAxisGuiding{true};  // mount must be of an equatorial type: false means guiding along only HA-axis
 };
 
+struct MccSlewAndGuidingPoint : MccCelestialPoint,
+                                MccSimpleSlewAndGuidingModelParams<typename MccCelestialPoint::coord_t> {
+    typedef MccSimpleSlewAndGuidingModelParams<typename MccCelestialPoint::coord_t> slew_guiding_params_t;
+};
+
 
 /*   CHECK FOR CURRENT MOUNT POSITION IN PROHIBITED ZONES    */
 
@@ -100,24 +106,32 @@ template <traits::mcc_mount_telemetry_data_c TelemetryDataT,
           std::ranges::output_range<bool> ResT>
 auto mccCheckInZonePZRange(const TelemetryDataT& telemetry_data, const RT& pzones, ResT& result)
 {
+    bool in_zone = false;
+
     auto Npz = std::ranges::distance(pzones);
     if (!Npz) {
-        return;
+        return in_zone;
     }
 
     auto res_sz = std::ranges::distance(result);
+    bool ok;
 
     size_t i = 1;
     auto res_iter = result.begin();
     for (auto& el : pzones) {
+        ok = el.inZone(telemetry_data);
+        in_zone |= ok;
+
         if (i > res_sz) {
-            std::back_inserter(result) = el.inZone(telemetry_data);
+            std::back_inserter(result) = ok;
         } else {
             std::ranges::advance(res_iter, 1);
-            *res_iter = el.inZone(telemetry_data);
+            *res_iter = ok;
         }
         ++i;
     }
+
+    return in_zone;
 }
 
 }  // namespace mcc