mountcontrol/cxx/mcc_mount_telemetry.h

#pragma once

/*  MOUNT CONTROL COMPONENTS LIBRARY  */


/*  MOUNT TELEMETRY OBJECT CONCEPT AND POSSIBLE IMPLEMENTATION  */

#include <functional>
#include <mutex>

// #include "mcc_mount_config.h"
#include "mcc_mount_concepts.h"

namespace mcc
{


// namespace traits
// {

// template <typename T>
// concept mcc_mount_telemetry_c = requires(T t, const T t_const) {
//     typename T::error_t;
//     typename T::mount_telemetry_data_t;

//     { t_const.errorString(std::declval<typename T::error_t>()) } -> mcc_formattable;

//     { t.update() } -> std::same_as<typename T::error_t>;

//     { t_const.data() } -> std::same_as<typename T::mount_telemetry_data_t>;
// };

// }  // namespace traits

template <traits::mcc_astrom_engine_c ASTROM_ENGINE_T,
          traits::mcc_mount_pec_c PEC_T,
          traits::mcc_mount_hardware_c HARDWARE_T>
class MccMountTelemetry
{
public:
    typedef ASTROM_ENGINE_T astrom_engine_t;
    typedef PEC_T pec_t;
    typedef HARDWARE_T hardware_t;

    enum error_t : int { TEL_ERROR_OK = 0, TEL_ERROR_HARDWARE, TEL_ERROR_ASTROMETRY_COMP };

    // check for coordinate types consistency
    static_assert(std::convertible_to<typename hardware_t::coord_t, typename astrom_engine_t::coord_t>,
                  "HARDWARE COORDINATE TYPE MUST BE CONVERTIBLE TO ASTROMETRY ENGINE ONE!");

    static_assert(std::convertible_to<typename astrom_engine_t::coord_t, typename pec_t::coord_t>,
                  "ASTROMETRY ENGINE COORDINATE TYPE MUST BE CONVERTIBLE TO PEC ONE!");

    static_assert(std::same_as<typename astrom_engine_t::time_point_t, typename hardware_t::time_point_t>,
                  "TIME-POINT TYPE IN ASTROMETRY ENGINE AND HARDWARE MUST BE THE SAME!");

    // mount current telemetry data: time, position and related quantities
    struct mount_telemetry_data_t {
        typedef astrom_engine_t::coord_t mnt_coord_t;
        // typedef astrom_engine_t::coord_t mnt_speed_t;

        // time-related
        typename astrom_engine_t::time_point_t utc;          // time point of measurements, UTC
        typename astrom_engine_t::juldate_t jd;              // Julian date
        typename astrom_engine_t::sideral_time_t siderTime;  // local apperant sideral time
        // astrom_engine_t::time_point_t ut1;          // Universal time
        // astrom_engine_t::time_point_t tt;           // Terrestial time

        // apparent target (user-input) current coordinates (in radians)
        mnt_coord_t tagRA, tagDEC;
        mnt_coord_t tagHA;
        mnt_coord_t tagAZ, tagALT;
        mnt_coord_t tagPA;  // paralactic angle

        // encoder-measured current mount coordinates (in radians)
        mnt_coord_t mntRA, mntDEC;
        mnt_coord_t mntHA;
        mnt_coord_t mntAZ, mntALT;
        typename astrom_engine_t::pa_t mntPA;

        // encoder-measured (non-corrected for PCS) current mount position and moving speed (in radians, radians/s)
        // X - HA, Y - DEC for equatorial-type mount; X - AZ, Y - ALT for horizontal-type one
        mnt_coord_t mntPosX, mntPosY;
        // mnt_speed_t mntSpeedX, mntSpeedY;

        // current refraction coefficients
        typename pec_t::pec_result_t currRefrCoeffs;
        // current refraction correction (for mntALT)
        mnt_coord_t currRefr;

        // PEC (pointing error correction):
        // X - HA, Y - DEC for equatorial-type mount; X - AZ, Y - ALT for horizontal-type one
        mnt_coord_t pecX, pecY;
    };

    MccMountTelemetry(astrom_engine_t& astrom_engine, pec_t& pec, hardware_t& hardware)
    {
        // to be sure that arguments are captured by reference
        const auto astrom_engine_ptr = &astrom_engine;
        const auto pec_ptr = &pec;
        const auto hardware_ptr = &hardware;

        _updateImpl = [astrom_engine_ptr, pec_ptr, hardware_ptr, this]() {
            mount_telemetry_data_t current_data;

            // computing ...

            typename hardware_t::axes_pos_t ax_pos;

            auto err = hardware_ptr->getPos(ax_pos);
            if (err) {
                // logging?!!!
                return TEL_ERROR_HARDWARE;
            }

            _data.utc = ax_pos.time_point;
            _data.mntPosX = ax_pos.x;
            _data.mntPosY = ax_pos.y;

            // compute Julian date
            auto ast_err = astrom_engine_ptr->greg2jul(_data.utc, _data.jd);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }

            // compute local apparent sideral time
            ast_err = astrom_engine_ptr->apparentSiderTime(_data.jd, _data.siderTime, true);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }

            // compute equation of origins
            typename astrom_engine_t::eo_t eo;
            ast_err = astrom_engine_ptr->eqOrigins(_data.jd, eo);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }



            typename pec_t::pec_result_t pec_res;
            pec_res = pec_ptr->compute(ax_pos.x, ax_pos.y);

            if constexpr (mccIsEquatorialMount(pec_t::mountType)) {
                _data.mntHA = pec_res.x + ax_pos.x;
                _data.mntDEC = pec_res.y + ax_pos.y;

                ast_err = astrom_engine_ptr->hadec2azalt(_data.mntHA, _data.mntDEC, _data.mntAZ, _data.mntALT);
                if (ast_err) {
                    return TEL_ERROR_ASTROMETRY_COMP;
                }
            } else if constexpr (mccIsAltAzMount(pec_t::mountType)) {
                _data.mntAZ = pec_res.x + ax_pos.x;
                _data.mntALT = pec_res.y + ax_pos.x;

                ast_err = astrom_engine_ptr->azalt2hadec(_data.mntAZ, _data.mntALT, _data.mntHA, _data.mntDEC);
                if (ast_err) {
                    return TEL_ERROR_ASTROMETRY_COMP;
                }
            } else {
                static_assert(false, "UNSUPPORTED MOUNT TYPE!");
            }

            // compute CIO-based apparent RA
            _data.mntRA = _data.siderTime - _data.mntHA + eo;

            // compute PA
            ast_err = astrom_engine_ptr->hadec2pa(_data.mntHA, _data.mntDEC, _data.mntPA);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }

            ast_err = astrom_engine_ptr->refraction(_data.currRefrCoeffs);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }

            ast_err = astrom_engine_ptr->refractCorrection(_data.mntALT, _data.currRefrCoeffs, _data.currRefr);
            if (ast_err) {
                return TEL_ERROR_ASTROMETRY_COMP;
            }



            std::lock_guard lock{_updateMutex};

            _data = std::move(current_data);
        };
    }

    virtual ~MccMountTelemetry() = default;

    // update current data method
    error_t update()
    {
        _updateImpl();
    }

    mount_telemetry_data_t data(this auto&& self)
    {
        using self_t = decltype(self);

        std::lock_guard lock{std::forward<self_t>(self)._updateMutex};

        return std::move(std::forward<self_t>(self)._data);
    }


protected:
    mount_telemetry_data_t _data{};

    std::function<error_t()> _updateImpl{};

    std::mutex _updateMutex;
};

}  // namespace mcc