...

cxx/CMakeLists.txt

@@ -151,15 +151,15 @@ if (WITH_TESTS)
     target_include_directories(${FITPACK_TEST_APP} PRIVATE ${FITPACK_INCLUDE_DIR})
     # message(STATUS "INC UP: " ${FITPACK_INCLUDE_DIR})
 
-    set(FSM_TEST_APP fsm_test)
+    # set(FSM_TEST_APP fsm_test)
-    add_executable(${FSM_TEST_APP} tests/fsm_test.cpp)
+    # add_executable(${FSM_TEST_APP} tests/fsm_test.cpp)
 
 
-    # set(TESTS_SRC tests/configfile_test.cpp tests/astrom_test.cpp tests/fitpack_test.cpp tests/fsm_test.cpp)
+    set(TESTS_SRC tests/coord.cpp tests/fsm.cpp tests/mount.cpp)
-    set(TESTS_SRC tests/coord.cpp)
     create_test_sourcelist(Tests common_tests.cpp ${TESTS_SRC})
     add_executable(common_tests ${Tests})
-    # target_include_directories(common_tests PRIVATE ${FITPACK_INCLUDE_DIR})
+    target_include_directories(common_tests PRIVATE ${FITPACK_INCLUDE_DIR})
+    target_link_libraries(common_tests  fitpack)
 
     foreach (test ${TESTS_SRC})
       get_filename_component (TName ${test} NAME_WE)

cxx/mcc_mount.h

@@ -115,11 +115,11 @@ struct MccMountConfig {
 
     MccMountSiteInfo siteInfo{.latitude = 0.0, .longitude = 0.0, .elevation = 0.0, .name{"ALL-ZERO"}};
 
-    template <typename ComponentT, typename... CompCtorArgTs>
+    // template <typename ComponentT, typename... CompCtorArgTs>
-    auto update(this auto&& self, CompCtorArgTs... comp_ctor_args)
+    // auto update(this auto&& self, CompCtorArgTs... comp_ctor_args)
-    {
+    // {
-        return std::forward<decltype(self)>(self).updateImpl(std::forward<CompCtorArgTs>(comp_ctor_args)...);
+    //     return std::forward<decltype(self)>(self).updateImpl(std::forward<CompCtorArgTs>(comp_ctor_args)...);
-    }
+    // }
 };
 
 
@@ -153,9 +153,9 @@ public:
 
     /*  constructors and destructor  */
 
-    template <fsm::traits::fsm_state_c InitStateT>
+    template <fsm::traits::fsm_state_c InitStateT, traits::mcc_input_char_range LogMarkT = std::string_view>
     MccMount(InitStateT,
-             traits::mcc_input_char_range auto const& logger_mark = "[MOUNT]",
+             const LogMarkT& logger_mark = "[MOUNT]",
              std::shared_ptr<spdlog::logger> logger = spdlog::null_logger_mt("NULL"))
         : fsm::MccFiniteStateMachine(InitStateT{}), utils::MccSpdlogLogger(logger)
     {
@@ -186,13 +186,15 @@ public:
 
     mount_config_t mountConfig() const
     {
-        return _mountConfig.load();
+        return _mountConfig;
+        // return _mountConfig.load();
     }
 
 
     mount_telemetry_t mountTelemetry() const
     {
-        return _mountTelemetry.load();
+        return _mountTelemetry;
+        // return _mountTelemetry.load();
     }
 
 
@@ -238,8 +240,10 @@ public:
 
 
 protected:
-    std::atomic<mount_config_t> _mountConfig;
+    // std::atomic<mount_config_t> _mountConfig;
-    std::atomic<mount_telemetry_t> _mountTelemetry;
+    // std::atomic<mount_telemetry_t> _mountTelemetry;
+    mount_config_t _mountConfig;
+    mount_telemetry_t _mountTelemetry;
 
     typedef std::chrono::duration<double> pz_duration_t;
 

cxx/mcc_mount_coord.h

@@ -163,7 +163,10 @@ public:
         return *this;
     }
 
-    MccAngle& normalize() { return normalize<NORM_KIND_0_360>(); }
+    MccAngle& normalize()
+    {
+        return normalize<NORM_KIND_0_360>();
+    }
 
 
     // template <typename T>
@@ -173,7 +176,10 @@ public:
     //     return _angleInRads;
     // }
 
-    operator double() const { return _angleInRads; }
+    operator double() const
+    {
+        return _angleInRads;
+    }
 
 
     template <typename T>
@@ -182,7 +188,10 @@ public:
         return _angleInRads * 180.0 / std::numbers::pi;
     }
 
-    double degrees() const { return degrees<double>(); }
+    double degrees() const
+    {
+        return degrees<double>();
+    }
 
     template <traits::mcc_output_char_range T>
     T sexagesimal(bool hms = false, int prec = 2) const
@@ -190,7 +199,10 @@ public:
         return utils::rad2sxg(_angleInRads, hms, prec >= 0 ? prec : _precision);
     }
 
-    std::string sexagesimal(bool hms = false, int prec = 2) const { return sexagesimal<std::string>(hms, prec); }
+    std::string sexagesimal(bool hms = false, int prec = 2) const
+    {
+        return sexagesimal<std::string>(hms, prec);
+    }
 
 
     // arithmetics
@@ -331,18 +343,25 @@ class MccAngleAZ : public MccAngle
     using MccAngle::MccAngle;
 };
 
-struct MccAngleALT;  // just forward declaration
+class MccAngleALT;  // just forward declaration
 
-struct MccAngleZD : public MccAngle {
+class MccAngleZD : public MccAngle
+{
+public:
     using MccAngle::MccAngle;
 
     MccAngleZD(const MccAngleALT&);
 };
 
-struct MccAngleALT : public MccAngle {
+class MccAngleALT : public MccAngle
+{
+public:
     using MccAngle::MccAngle;
 
-    MccAngleALT(const MccAngleZD& zd) { _angleInRads = std::numbers::pi / 2.0 - (double)zd; }
+    MccAngleALT(const MccAngleZD& zd)
+    {
+        _angleInRads = std::numbers::pi / 2.0 - (double)zd;
+    }
 };
 
 

cxx/mcc_mount_events_states.h

@@ -27,7 +27,10 @@ public:
 
     virtual ~MccMountEventBase() = default;
 
-    mount_t& mount() const { return _mount; }
+    mount_t& mount() const
+    {
+        return _mount;
+    }
 
 protected:
     MccMountEventBase(mount_t& mount) : _mount(mount) {}
@@ -74,7 +77,10 @@ struct MccMountEventError : public MccMountEventBase<MountT> {
 
     using event_data_t = std::error_code;
 
-    event_data_t eventData() const { return _error; }
+    event_data_t eventData() const
+    {
+        return _error;
+    }
 
     MccMountEventError(MountT& mount, const event_data_t& error) : base_t(mount), _error(error) {}
 
@@ -93,7 +99,10 @@ struct MccMountEventSlew : public MccMountEventBase<MountT> {
 
     using event_data_t = typename MountT::slew_param_t;
 
-    event_data_t eventData() const { return _eventData; }
+    event_data_t eventData() const
+    {
+        return _eventData;
+    }
 
     MccMountEventSlew(MountT& mount, const event_data_t& ev_data) : base_t(mount), _eventData(ev_data) {}
 
@@ -129,7 +138,10 @@ struct MccMountEventStop : public MccMountEventBase<MountT> {
         EVENT_STOP_BUTTON   // hardware button
     };
 
-    event_data_t eventData() const { return _reason; }
+    event_data_t eventData() const
+    {
+        return _reason;
+    }
 
     std::string_view reason() const
     {
@@ -187,13 +199,13 @@ protected:
     template <std::derived_from<MccMountEventBase<MountT>> EvT>
     void exitImpl(EvT& event)
     {
-        event.mount().logWarning("Call an empty MccMountStateBase::exitImpl method!!! Event type is '{}'", EvT::ID);
+        event.mount().logWarn("Call an empty MccMountStateBase::exitImpl method!!! Event type is '{}'", EvT::ID);
     }
 
     template <std::derived_from<MccMountEventBase<MountT>> EvT>
     void enterImpl(EvT& event)
     {
-        event.mount().logWarning("Call an empty MccMountStateBase::enterImpl method!!! Event type is '{}'", EvT::ID);
+        event.mount().logWarn("Call an empty MccMountStateBase::enterImpl method!!! Event type is '{}'", EvT::ID);
     }
 };
 
@@ -315,7 +327,10 @@ protected:
             EvT::ID);
     }
 
-    void exitImpl(MccMountEventIDLE<MountT>& event) { event.mount().logWarning("Suppose the error was corrected!"); }
+    void exitImpl(MccMountEventIDLE<MountT>& event)
+    {
+        event.mount().logWarning("Suppose the error was corrected!");
+    }
 
     void exitImpl(MccMountEventInit<MountT>& event)
     {
@@ -400,4 +415,34 @@ protected:
     }
 };
 
+
+
+// guiding state
+
+template <traits::mcc_mount_c MountT>
+struct MccMountStateGuiding : MccMountStateBase<MountT> {
+    static constexpr std::string_view ID = "MCC-MOUNT-GUIDING-STATE";
+
+    // only initialization
+    using transition_t =
+        fsm::fsm_transition_table_t<std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>,
+                                    std::pair<MccMountEventError<MountT>, MccMountStateStop<MountT>>,
+                                    // std::pair<MccMountEventSlew<MountT>, MccMountStateSlew<MountT>>,
+                                    std::pair<MccMountEventGuiding<MountT>, MccMountStateStop<MountT>>,
+                                    std::pair<MccMountEventStop<MountT>, MccMountStateStop<MountT>>,
+                                    std::pair<MccMountEventShutdown<MountT>, MccMountStateStop<MountT>>>;
+
+protected:
+    template <std::derived_from<MccMountEventBase<MountT>> EvT>
+    void exitImpl(EvT& event)
+    {
+    }
+
+    template <std::derived_from<MccMountEventSlew<MountT>> EvT>
+    void enterImpl(EvT& event)
+    {
+        event.mount().slewMount(/* params here ...*/);
+    }
+};
+
 }  // namespace mcc

cxx/tests/fitpack.cpp

@@ -0,0 +1,127 @@
+#include <algorithm>
+#include <functional>
+#include <iostream>
+#include <random>
+#include <ranges>
+
+#include "../fitpack/fitpack.h"
+
+int tests_fitpack(int, char**)
+{
+    size_t nt = 30, np = 60, N = nt * np, i = 1;
+    // size_t nt = 10, np = 20, N = nt * np, i = 1;
+    double ts = std::numbers::pi / (nt + 1);
+    double ps = 2.0 * std::numbers::pi / (np + 1);
+
+    std::vector<double> tetha(N), phi(N), func(N);
+
+    auto gen_func = [](double st, size_t& idx) {
+        double v = st * idx;
+        ++idx;
+
+        return v;
+    };
+
+    auto print_func = [](const auto& r, std::string_view name) {
+        std::cout << name << ": ";
+        for (auto& el : r) {
+            std::cout << el << " ";
+        }
+        std::cout << "\n";
+    };
+
+
+    // std::ranges::generate(tetha, std::bind(gen_func, ts, i));
+
+    // i = 1;
+    // std::ranges::generate(phi, std::bind(gen_func, ps, i));
+
+    size_t k = 1;
+    i = 0;
+    for (size_t j = 0; j < nt; ++j) {
+        std::ranges::fill_n(tetha.begin() + i * np, np, ts * (i + 1));
+        std::ranges::generate(phi | std::views::drop(i * np) | std::views::take(np), std::bind(gen_func, ps, k));
+        ++i;
+        k = 1;
+    }
+
+    // std::uniform_real_distribution<double> distr{-0.1, 0.1};
+    std::normal_distribution<double> distr{0.0, 1.0};
+    std::random_device device;
+    std::mt19937 engine{device()};
+
+    std::ranges::generate(func, [ii = 0, &distr, &engine, &tetha, &phi]() mutable {
+        double v = (5.0 + tetha[ii]) * 1.3 + (3.0 + phi[ii]) * 3.1 + distr(engine);
+        ++ii;
+        return v;
+    });
+
+
+    int ntk = 24, npk = 29, nf = (ntk + 4) * (npk + 4);
+    // int ntk = 3, npk = 6, nf = (ntk + 4) * (npk + 4);
+    std::vector<double> tk(ntk + 8), pk(npk + 8), coeffs(nf);
+    ts = std::numbers::pi / (ntk + 1);
+    ps = 2.0 * std::numbers::pi / (npk + 1);
+
+    i = 1;
+    std::ranges::generate(tk | std::views::drop(4) | std::views::take(ntk), std::bind(gen_func, ts, i));
+    i = 1;
+    std::ranges::generate(pk | std::views::drop(4) | std::views::take(npk), std::bind(gen_func, ps, i));
+
+
+    double rs = 0.0;
+    int ec = mcc::fitpack::fitpack_sphere_fit(tetha, phi, func, 1.0, tk, pk, coeffs, rs);
+
+    std::cout << "FIT EC = " << ec << "\n";
+    std::cout << "FIT RESI = " << rs << "\n";
+
+    ntk += 8;
+    npk += 8;
+    std::ranges::fill(tk, -1);
+    std::ranges::fill(pk, -1);
+    ec = mcc::fitpack::fitpack_sphere_smooth(tetha, phi, func, 1.0, 1800.0, ntk, npk, tk, pk, coeffs, rs);
+
+    std::cout << "FIT EC = " << ec << "\n";
+    std::cout << "FIT RESI = " << rs << "\n";
+    std::cout << "NKNOTS: " << ntk << ", " << npk << "\n";
+
+
+    print_func(coeffs, "coeffs");
+
+    // print_func(tetha, "tetha");
+    // print_func(phi, "phi");
+    print_func(tk, "tetha_knots");
+    print_func(pk, "phi_knots");
+    print_func(func, "func");
+
+    std::cout << "\n\n";
+
+    k = 1;
+    ts = std::numbers::pi / (nt + 1);
+    std::ranges::generate_n(tetha.begin(), nt, std::bind(gen_func, ts, k));
+
+    std::vector<double> f_func;
+    tetha.resize(nt);
+    phi.resize(np);
+
+    tk.resize(ntk);
+    pk.resize(npk);
+
+    print_func(tetha, "TETHA:");
+    print_func(phi, "PHI:");
+
+    ec = mcc::fitpack::fitpack_eval_spl2d(tk, pk, coeffs, tetha, phi, f_func);
+    // ec = mcc::fitpack::fitpack_eval_spl2d(pk, tk, coeffs, phi, tetha, f_func);
+    std::cout << "EVAL EC = " << ec << "\n";
+    print_func(f_func, "func");
+
+    std::cout << "\n\n";
+
+    for (size_t l = 0; l < f_func.size(); ++l) {
+        auto r = f_func[l] - func[l];
+        std::cout << r << " ";
+    }
+    std::cout << "\n";
+
+    return 0;
+}

cxx/tests/fsm.cpp

@@ -0,0 +1,147 @@
+#include <cxxabi.h>
+#include <iostream>
+#include <typeinfo>
+
+#include "../mcc_finite_state_machine.h"
+
+using namespace mcc;
+
+
+struct S {
+};
+
+
+struct EV1 {
+    static constexpr std::string_view ID = "EV1";
+
+    void onTransit()
+    {
+        //
+        std::cout << "EV1::onTransit()\n";
+    }
+};
+
+struct EV2 {
+    static constexpr std::string_view ID = "EV2";
+};
+
+struct EV3 {
+    static constexpr std::string_view ID = "EV3";
+};
+
+struct EVN {
+    static constexpr std::string_view ID = "EVN";
+};
+
+struct ST1;
+struct ST2;
+
+struct STN {
+    static constexpr std::string_view ID = "STN";
+    using transition_t = fsm::fsm_transition_table_t<std::pair<EV1, STN>, std::pair<EV2, ST2>>;
+
+    void enter()
+    {
+        std::cout << "transit to " << ID << "-state\n";
+    }
+
+    void exit()
+    {
+        std::cout << "transit from " << ID << "-state\n";
+    }
+};
+
+struct ST3 {
+    static constexpr std::string_view ID = "ST3";
+    using transition_t = fsm::fsm_transition_table_t<std::pair<EV1, ST1>, std::pair<EV2, ST2>>;
+
+    void enter(EV3& ev)
+    {
+        std::cout << "transit to " << ID << "-state\n";
+    }
+
+    void exit()
+    {
+        std::cout << "transit from " << ID << "-state\n";
+    }
+};
+
+struct ST2 {
+    static constexpr std::string_view ID = "ST2";
+    using transition_t = fsm::fsm_transition_table_t<std::pair<EV2, STN>, std::pair<EV3, ST3>>;
+
+    void enter(EV2& ev)
+    {
+        std::cout << "transit to " << ID << "-state\n";
+    }
+
+    void exit()
+    {
+        std::cout << "transit from " << ID << "-state\n";
+    }
+};
+
+struct ST1 {
+    static constexpr std::string_view ID = "ST1";
+    using transition_t =
+        fsm::fsm_transition_table_t<std::pair<EV1, ST2>, std::pair<EV2, STN>, std::pair<EV3, STN>, std::pair<EV3, STN>>;
+
+    void enter()
+    {
+        std::cout << "transit to " << ID << "-state\n";
+    }
+
+    void exit()
+    {
+        std::cout << "transit from " << ID << "-state\n";
+    }
+};
+
+
+
+int tests_fsm(int, char**)
+{
+    std::cout << "\n\n\n------- mcc_finite_state_machine.h -------\n";
+
+
+
+    fsm::MccFiniteStateMachine fsmach(ST1{});
+
+    std::cout << "STATES: ";
+    for (auto& el : fsmach.stateIDs()) {
+        std::cout << std::quoted(el) << " ";
+    }
+    std::cout << "\n";
+
+    std::cout << "EVENTS: ";
+    for (auto& el : fsmach.eventIDs()) {
+        std::cout << std::quoted(el) << " ";
+    }
+    std::cout << "\n";
+
+    fsmach.dispatchEvent<EV1>();
+    fsmach.dispatchEvent<EV3>();
+    fsmach.dispatchEvent<EV2>();
+
+    // fsmach.dispatchEvent<EVN>();
+
+    using tab_t = fsm::fsm_transition_table_t<std::pair<EV1, ST2>, std::pair<EV3, ST1>>;
+
+    using st_t = tab_t::find_state_by_event_t<EV2>;
+
+    int status;
+    char* aa = abi::__cxa_demangle(typeid(st_t).name(), NULL, NULL, &status);
+    std::cout << "aa = " << aa << "\n";
+    free(aa);
+
+    std::cout << "\nAfter std::move\n";
+    auto fsmach1 = std::move(fsmach);
+    std::cout << "STATES: ";
+    for (auto& el : fsmach1.stateIDs()) {
+        std::cout << std::quoted(el) << " ";
+    }
+    std::cout << "\n";
+    std::cout << "current state: " << std::quoted(fsmach1.currentStateID()) << "\n";
+
+    return 0;
+}

cxx/tests/mount.cpp

@@ -0,0 +1,15 @@
+#include "../mcc_mount.h"
+#include "../mcc_mount_events_states.h"
+
+int tests_mount(int, char**)
+{
+    using namespace mcc;
+
+    using mount_t = MccMount<MccMountConfig<MccMountType::CROSSAXIS_TYPE>, MccMountTelemetry>;
+
+    mount_t mount(MccMountStateIDLE<mount_t>{});
+
+
+
+    return 0;
+}