782 lines
31 KiB
C++
782 lines
31 KiB
C++
#pragma once
|
|
|
|
/* MOUNT CONTROL COMPONENTS LIBRARY */
|
|
|
|
#include <concepts>
|
|
|
|
#include "mcc_finite_state_machine.h"
|
|
#include "mcc_mount_coord.h"
|
|
#include "mcc_traits.h"
|
|
|
|
/* SOME LIBRARY-WIDE DECLARATIONS */
|
|
|
|
namespace mcc
|
|
{
|
|
// mount construction type (only the most common ones)
|
|
enum class MccMountType : uint8_t { GERMAN_TYPE, FORK_TYPE, CROSSAXIS_TYPE, ALTAZ_TYPE };
|
|
|
|
template <MccMountType TYPE>
|
|
static constexpr std::string_view MccMountTypeStr = TYPE == MccMountType::GERMAN_TYPE ? "GERMAN"
|
|
: TYPE == MccMountType::FORK_TYPE ? "FORK"
|
|
: TYPE == MccMountType::CROSSAXIS_TYPE ? "CROSSAXIS"
|
|
: TYPE == MccMountType::ALTAZ_TYPE ? "ALTAZ"
|
|
: "UNKNOWN";
|
|
|
|
template <MccMountType TYPE>
|
|
static constexpr bool mcc_is_equatorial_mount = TYPE == MccMountType::GERMAN_TYPE ? true
|
|
: TYPE == MccMountType::FORK_TYPE ? true
|
|
: TYPE == MccMountType::CROSSAXIS_TYPE ? true
|
|
: TYPE == MccMountType::ALTAZ_TYPE ? false
|
|
: false;
|
|
template <MccMountType TYPE>
|
|
static constexpr bool mcc_is_altaz_mount = TYPE == MccMountType::GERMAN_TYPE ? false
|
|
: TYPE == MccMountType::FORK_TYPE ? false
|
|
: TYPE == MccMountType::CROSSAXIS_TYPE ? false
|
|
: TYPE == MccMountType::ALTAZ_TYPE ? true
|
|
: false;
|
|
|
|
static consteval bool mccIsEquatorialMount(const MccMountType type)
|
|
{
|
|
return type == MccMountType::GERMAN_TYPE ? true
|
|
: type == MccMountType::FORK_TYPE ? true
|
|
: type == MccMountType::CROSSAXIS_TYPE ? true
|
|
: type == MccMountType::ALTAZ_TYPE ? false
|
|
: false;
|
|
};
|
|
|
|
static consteval bool mccIsAltAzMount(const MccMountType type)
|
|
{
|
|
return type == MccMountType::GERMAN_TYPE ? false
|
|
: type == MccMountType::FORK_TYPE ? false
|
|
: type == MccMountType::CROSSAXIS_TYPE ? false
|
|
: type == MccMountType::ALTAZ_TYPE ? true
|
|
: false;
|
|
};
|
|
|
|
|
|
/* NULL-LOGGER CLASS */
|
|
|
|
struct MccNullLogger {
|
|
typedef int loglevel_t;
|
|
|
|
void setLogLevel(loglevel_t){};
|
|
loglevel_t getLogLevel() const
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
void logMessage(loglevel_t, const std::string&) {};
|
|
void logError(const std::string&) {};
|
|
void logDebug(const std::string&) {};
|
|
void logWarn(const std::string&) {};
|
|
void logInfo(const std::string&) {};
|
|
};
|
|
|
|
|
|
|
|
} // namespace mcc
|
|
|
|
|
|
|
|
/* MOUNT COMPONENTS CONCEPTS */
|
|
|
|
namespace mcc::traits
|
|
{
|
|
|
|
|
|
/* GENERIC LOGGER */
|
|
|
|
template <typename T>
|
|
concept mcc_logger_c = requires(T t, const T t_const) {
|
|
typename T::loglevel_t;
|
|
{ t.setLogLevel(std::declval<typename T::loglevel_t>()) };
|
|
{ t_const.getLogLevel() } -> std::same_as<typename T::loglevel_t>;
|
|
|
|
{ t.logMessage(std::declval<typename T::loglevel_t>(), std::declval<const std::string&>()) };
|
|
|
|
{ t.logError(std::declval<const std::string&>()) };
|
|
{ t.logDebug(std::declval<const std::string&>()) };
|
|
{ t.logWarn(std::declval<const std::string&>()) };
|
|
{ t.logInfo(std::declval<const std::string&>()) };
|
|
};
|
|
|
|
|
|
/* A CONCEPT FOR COORDINATE REPRESENTATION */
|
|
|
|
// it is a fundametal floating-point type or
|
|
// a class that can be constructed from or converted to the double fundametal type
|
|
template <typename T>
|
|
concept mcc_coord_t = std::floating_point<T> || (std::convertible_to<T, double> && std::constructible_from<T, double>);
|
|
|
|
|
|
/* A CONCEPT FOR UTC TIME POINT REPRESENTATION */
|
|
|
|
// it is a std::chrono::sys_time<Duration> or
|
|
// fundamental arithmetic type that represent number of seconds after the 00:00:00 of 1 January 1970 (UNIX time)
|
|
template <typename T>
|
|
concept mcc_utc_time_point_c = mcc_systime_c<T> || std::is_arithmetic_v<T>;
|
|
|
|
/* A CONCEPT FOR CLASS TO REPRESENT CELESTIAL POINT */
|
|
|
|
|
|
template <typename T>
|
|
concept mcc_celestial_point_c = requires(T t) {
|
|
// a type to represent UTC time point of coordinates
|
|
// it's clear that this makes sense for apparent coordinates
|
|
typename T::time_point_t;
|
|
|
|
// coordinates pair type (e.g. IRCS RA,DEC, Az,Alt and so on)
|
|
requires std::same_as<decltype(t.coordPairKind), MccCoordPairKind>;
|
|
|
|
typename T::coord_t;
|
|
|
|
// co-longitude (e.g. RA or Az)
|
|
requires std::same_as<decltype(t.x), typename T::coord_t>;
|
|
|
|
// co-latitude (e.g. DEC or ZD)
|
|
requires std::same_as<decltype(t.y), typename T::coord_t>;
|
|
};
|
|
|
|
|
|
/* ASTROMETRY-RELATED COMPUTATION ENGINE */
|
|
|
|
template <typename T>
|
|
concept mcc_astrom_engine_c = requires(T t, const T t_const) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
// typename T::engine_state_t;
|
|
// requires std::movable<typename T::engine_state_t>;
|
|
|
|
typename T::coord_t; // type for coordinates representation
|
|
typename T::time_point_t; // type to represent UTC time point
|
|
typename T::juldate_t; // type to represent Julian date
|
|
typename T::sideral_time_t; // type to represent sideral time
|
|
typename T::eo_t; // equation of origins
|
|
typename T::pa_t; // type to represent parallactic angle
|
|
|
|
typename T::refract_result_t;
|
|
|
|
|
|
/* coordinates conversional methods */
|
|
|
|
// ICRS RA and DEC to observed place: icrs2obs(ra, dec, jd, ra_app, dec_app, ha, az, alt, eo)
|
|
{
|
|
t.icrs2obs(std::declval<typename T::coord_t>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::juldate_t>(), std::declval<typename T::coord_t&>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::coord_t&>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::coord_t&>(),
|
|
std::declval<typename T::eo_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
// observed place to ICRS RA and DEC: obs2icrs(type, x, y, jd, ra_icrs, dec_icrs)
|
|
// (x, y) = (AZ, ZD) if type == MccCoordPairKind::COORDS_KIND_AZZD
|
|
// (x, y) = (AZ, ALT) if type == MccCoordPairKind::COORDS_KIND_AZALT
|
|
// (x, y) = (HA, DEC) if type == MccCoordPairKind::COORDS_KIND_HADEC_APP
|
|
// (x, y) = (RA, DEC) if type == MccCoordPairKind::COORDS_KIND_RADEC_APP
|
|
{
|
|
t.obs2icrs(std::declval<MccCoordPairKind>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::coord_t>(), std::declval<typename T::juldate_t>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::coord_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
|
|
// compute hour angle and declination from azimuth and altitude: hadec2azalt(ha, dec, az, alt)
|
|
{
|
|
t.hadec2azalt(std::declval<typename T::coord_t>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::coord_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
// compute azimuth and altitude from hour angle and declination: azalt2hadec(az, alt, ha, dec)
|
|
{
|
|
t.azalt2hadec(std::declval<typename T::coord_t>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::coord_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
// compute parallactic angle: hadec2pa(ha, dec, pa)
|
|
{
|
|
t.hadec2pa(std::declval<typename T::coord_t>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::pa_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
|
|
// transform coordinates according to its pair types and time points (a high-level wrapper):
|
|
//
|
|
// coord2coord(coord_pair_kind_from, x_from, y_from, time_point_from, coord_pair_kind_to, x_to, y_to, time_point_to)
|
|
//
|
|
// (x_*, y_*) = (AZ, ZD) if coord_pair_kind_* == MccCoordPairKind::COORDS_KIND_AZZD
|
|
// (x_*, y_*) = (AZ, ALT) if coord_pair_kind_* == MccCoordPairKind::COORDS_KIND_AZALT
|
|
// (x_*, y_*) = (HA, DEC) if coord_pair_kind_* == MccCoordPairKind::COORDS_KIND_HADEC_APP (apparent)
|
|
// (x_*, y_*) = (RA, DEC) if coord_pair_kind_* == MccCoordPairKind::COORDS_KIND_RADEC_APP (apparent)
|
|
// (x_*, y_*) = (RA, DEC) if coord_pair_kind_* == MccCoordPairKind::COORDS_KIND_RADEC_ICRS (ICRS)
|
|
//
|
|
// if coord_pair_kind_* and time_point_* are equal then x_to = x_from, y_to = y_from
|
|
{
|
|
t.coord2coord(std::declval<MccCoordPairKind>(), std::declval<typename T::coord_t>(),
|
|
std::declval<typename T::coord_t>(), std::declval<typename T::time_point_t>(),
|
|
std::declval<MccCoordPairKind>(), std::declval<typename T::coord_t&>(),
|
|
std::declval<typename T::coord_t&>(), std::declval<typename T::time_point_t>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
|
|
// compute equation of origins
|
|
{
|
|
t.eqOrigins(std::declval<typename T::juldate_t>(), std::declval<typename T::eo_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
|
|
/* time-related methods */
|
|
|
|
// this static method must return a current time point
|
|
{ T::timePointNow() } -> std::same_as<typename T::time_point_t>;
|
|
|
|
// Gregorian Calendar time point to Julian Date: greg2jul(time_point, jd)
|
|
{
|
|
t.greg2jul(std::declval<typename T::time_point_t>(), std::declval<typename T::juldate_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
// apparent sideral time: apparentSiderTime(jd, st, islocal)
|
|
// if islocal == false then the method must return the Greenwich apparent sideral time, otherwise - local one
|
|
{
|
|
t.apparentSiderTime(std::declval<typename T::juldate_t>(), std::declval<typename T::sideral_time_t&>(),
|
|
std::declval<bool>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
|
|
|
|
/* atmospheric refraction-related methods */
|
|
|
|
// compute refraction-related quantities: refraction(refr_params)
|
|
{ t.refraction(std::declval<typename T::refract_result_t&>()) } -> std::same_as<typename T::error_t>;
|
|
|
|
// compute refraction correction for given altitude: refractCorrection(alt, refr_params, refr_corr)
|
|
{
|
|
t.refractCorrection(std::declval<typename T::coord_t>(), std::declval<typename T::refract_result_t>(),
|
|
std::declval<typename T::coord_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
};
|
|
|
|
|
|
/* A VERY GENERIC MOUNT HARDWARE CONCEPT */
|
|
|
|
template <typename T>
|
|
concept mcc_mount_hardware_c = !std::copyable<T> && std::movable<T> && requires(T t, const T t_const) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
|
|
typename T::time_point_t;
|
|
typename T::coord_t;
|
|
|
|
{ t_const.id() } -> mcc_formattable;
|
|
|
|
// a type that defines at least HW_MOVE_SLEWING, HW_MOVE_ADJUSTING, HW_MOVE_TRACKING
|
|
// and HW_MOVE_GUIDING compile-time constants. The main purpose of this type is a
|
|
// possible tunning of hardware setPos-related commands
|
|
//
|
|
// e.g. an implementations can be as follows:
|
|
// enum class hw_moving_type_t: int {HW_MOVE_SLEWING, HW_MOVE_ADJUSTING, HW_MOVE_TRACKING, HW_MOVE_GUIDING}
|
|
//
|
|
// struct hw_moving_type_t {
|
|
// 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::hw_moving_type_t state) {
|
|
[]() {
|
|
// hardware was asked for slewing (move to given celestial point)
|
|
static constexpr auto v1 = T::hw_moving_type_t::HW_MOVE_SLEWING;
|
|
|
|
// hardware was asked for adjusting after slewing ("seeking" given celestial point at the end of slewing
|
|
// process)
|
|
static constexpr auto v2 = T::hw_moving_type_t::HW_MOVE_ADJUSTING;
|
|
|
|
// hardware was asked for tracking (track given celestial point)
|
|
static constexpr auto v3 = T::hw_moving_type_t::HW_MOVE_TRACKING;
|
|
|
|
// hardware was asked for guiding (small corrections to track given celestial point)
|
|
static constexpr auto v4 = T::hw_moving_type_t::HW_MOVE_GUIDING;
|
|
}();
|
|
};
|
|
|
|
|
|
|
|
// a class that contains at least time of measurement, coordinates for x,y axes and its moving rates
|
|
requires requires(typename T::axes_pos_t pos) {
|
|
requires std::same_as<decltype(pos.time_point), typename T::time_point_t>; // time point
|
|
|
|
requires std::same_as<decltype(pos.x), typename T::coord_t>; // co-longitude coordinate
|
|
requires std::same_as<decltype(pos.y), typename T::coord_t>; // co-latitude coordinate
|
|
|
|
requires std::same_as<decltype(pos.xrate), typename T::coord_t>;
|
|
requires std::same_as<decltype(pos.yrate), typename T::coord_t>;
|
|
|
|
requires std::same_as<decltype(pos.moving_type), typename T::hw_moving_type_t>; // a 'hint' to hardware
|
|
};
|
|
|
|
// 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>;
|
|
|
|
// get current positions and speeds (angles) of mount axes
|
|
{ t.getPos(std::declval<typename T::axes_pos_t&>()) } -> std::same_as<typename T::error_t>;
|
|
|
|
{ t.stop() } -> std::same_as<typename T::error_t>; // stop any moving
|
|
{ t.init() } -> std::same_as<typename T::error_t>; // initialize hardware
|
|
};
|
|
|
|
|
|
/* POINTING-ERROR CORRECTION */
|
|
|
|
template <typename T>
|
|
concept mcc_mount_pec_c = requires(T t) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
typename T::coord_t;
|
|
|
|
// the 'T' class must contain static constexpr member of 'MccMountType' type
|
|
requires requires {
|
|
requires std::same_as<decltype(T::mountType), const MccMountType>;
|
|
[]() {
|
|
static constexpr MccMountType val = T::mountType;
|
|
return val;
|
|
}(); // to ensure 'mountType' can be used in compile-time context
|
|
};
|
|
|
|
// a class that contains at least .dx and .dy public fields
|
|
requires requires(typename T::pec_result_t res) {
|
|
requires std::same_as<decltype(res.dx), typename T::coord_t>;
|
|
requires std::same_as<decltype(res.dy), typename T::coord_t>;
|
|
};
|
|
|
|
{
|
|
t.compute(std::declval<const typename T::coord_t&>(), std::declval<const typename T::coord_t&>(),
|
|
std::declval<typename T::pec_result_t&>())
|
|
} -> std::same_as<typename T::error_t>;
|
|
};
|
|
|
|
|
|
/* MOUNT STATE TELEMETRY */
|
|
|
|
// a class that contains at least celestial (equatorial and horizontal) and harware coordinates
|
|
template <typename T>
|
|
concept mcc_mount_telemetry_data_c = std::movable<T> && requires(T telemetry) {
|
|
typename T::coord_t;
|
|
typename T::time_point_t;
|
|
|
|
// time point
|
|
requires std::same_as<decltype(telemetry.time_point), typename T::time_point_t>;
|
|
|
|
// target sky point ICRS and current coordinates
|
|
requires std::same_as<decltype(telemetry.tagRA), typename T::coord_t>; // apparent RA
|
|
requires std::same_as<decltype(telemetry.tagDEC), typename T::coord_t>; // apparent DEC
|
|
requires std::same_as<decltype(telemetry.tagHA), typename T::coord_t>; // hour angle
|
|
requires std::same_as<decltype(telemetry.tagAZ), typename T::coord_t>; // azimuth
|
|
requires std::same_as<decltype(telemetry.tagALT), typename T::coord_t>; // altitude
|
|
|
|
// mount current coordinates
|
|
requires std::same_as<decltype(telemetry.mntRA), typename T::coord_t>; // apparent RA
|
|
requires std::same_as<decltype(telemetry.mntDEC), typename T::coord_t>; // apparent DEC
|
|
requires std::same_as<decltype(telemetry.mntHA), typename T::coord_t>; // hour angle
|
|
requires std::same_as<decltype(telemetry.mntAZ), typename T::coord_t>; // azimuth
|
|
requires std::same_as<decltype(telemetry.mntALT), typename T::coord_t>; // altitude
|
|
|
|
requires std::same_as<decltype(telemetry.mntPosX), typename T::coord_t>; // hardware encoder X-axis position
|
|
requires std::same_as<decltype(telemetry.mntPosY), typename T::coord_t>; // hardware encoder Y-axis position
|
|
requires std::same_as<decltype(telemetry.mntRateX), typename T::coord_t>; // hardware encoder X-axis rate
|
|
requires std::same_as<decltype(telemetry.mntRateY), typename T::coord_t>; // hardware encoder Y-axis rate
|
|
|
|
// corrections to transform mount hardware coordinates to apparent
|
|
// (pointing error corrections)
|
|
requires std::same_as<decltype(telemetry.pecX), typename T::coord_t>;
|
|
requires std::same_as<decltype(telemetry.pecY), typename T::coord_t>;
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
concept mcc_mount_telemetry_c = requires(T t, const T t_const) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
|
|
// // a class that at least contains celestial (equatorial and horizontal) coordinates
|
|
// requires requires(typename T::mount_telemetry_data_t telemetry) {
|
|
// typename T::mount_telemetry_data_t::coord_t;
|
|
// requires std::same_as<decltype(telemetry.mntRA), typename T::mount_telemetry_data_t::coord_t>; //
|
|
// apparent RA requires std::same_as<decltype(telemetry.mntDEC), typename
|
|
// T::mount_telemetry_data_t::coord_t>; // apparent DEC requires std::same_as<decltype(telemetry.mntHA),
|
|
// typename T::mount_telemetry_data_t::coord_t>;
|
|
// // hour angle requires std::same_as<decltype(telemetry.mntAZ), typename
|
|
// T::mount_telemetry_data_t::coord_t>;
|
|
// // azimuth requires std::same_as<decltype(telemetry.mntALT), typename
|
|
// T::mount_telemetry_data_t::coord_t>; // altitude
|
|
// };
|
|
|
|
requires mcc_mount_telemetry_data_c<typename T::mount_telemetry_data_t>;
|
|
|
|
{ t.update() } -> std::same_as<typename T::error_t>;
|
|
|
|
{ t.data(std::declval<typename T::mount_telemetry_data_t&>()) } -> std::same_as<typename T::error_t>;
|
|
};
|
|
|
|
|
|
|
|
// /* SLEW PARAMETERS */
|
|
|
|
// template <typename T>
|
|
// concept mcc_slew_params_c = std::movable<T> && requires(T t) {
|
|
// // input coordinates pair type (e.g. IRCS RA,DEC, Az,Alt and so on)
|
|
// requires std::same_as<decltype(t.coordPairKind), MccCoordPairKind>;
|
|
|
|
// typename T::coord_t;
|
|
|
|
// // co-longitude (e.g. RA or Az)
|
|
// requires std::same_as<decltype(t.x), typename T::coord_t>;
|
|
|
|
// // co-latitude (e.g. DEC or ZD)
|
|
// requires std::same_as<decltype(t.y), typename T::coord_t>;
|
|
|
|
// // stop after slewing
|
|
// requires std::convertible_to<decltype(t.stop), bool>;
|
|
// };
|
|
|
|
|
|
/* GENERIC SLEW AND GUIDING MODEL */
|
|
|
|
template <typename T>
|
|
concept mcc_slew_model_c = requires(T t) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
// requires mcc_slew_params_c<typename T::slew_params_t>;
|
|
requires mcc_celestial_point_c<typename T::slew_point_t>;
|
|
|
|
// { t.slew(std::declval<typename T::slew_params_t>()) } -> std::same_as<typename T::error_t>;
|
|
{ t.slew(std::declval<typename T::slew_point_t>()) } -> std::same_as<typename T::error_t>;
|
|
{ t.stop() } -> std::same_as<typename T::error_t>;
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
concept mcc_guiding_model_c = requires(T t) {
|
|
requires mcc_error_c<typename T::error_t>;
|
|
requires mcc_celestial_point_c<typename T::guiding_point_t>;
|
|
|
|
// start process of guiding
|
|
{ t.guiding(std::declval<typename T::guiding_point_t>()) } -> std::same_as<typename T::error_t>;
|
|
{ t.stop() } -> std::same_as<typename T::error_t>;
|
|
};
|
|
|
|
|
|
/* MOUNT PROHIBITED ZONE */
|
|
|
|
|
|
struct MccPzoneAbstractInterface {
|
|
bool inZone(this auto&& self, mcc_mount_telemetry_data_c auto const& telemetry_data)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::inZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).inZone(telemetry_data);
|
|
}
|
|
}
|
|
|
|
bool inZone(this auto&& self, mcc_celestial_point_c auto const& sky_point)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::inZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).inZone(sky_point);
|
|
}
|
|
}
|
|
|
|
// returns a time to reach the zone
|
|
auto timeTo(this auto&& self, mcc_mount_telemetry_data_c auto const& telemetry_data)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::timeTo method");
|
|
} else {
|
|
return std::forward<self_t>(self).timeTo(telemetry_data);
|
|
}
|
|
}
|
|
|
|
auto timeTo(this auto&& self, mcc_celestial_point_c auto const& sky_point)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::timeTo method");
|
|
} else {
|
|
return std::forward<self_t>(self).timeTo(sky_point);
|
|
}
|
|
}
|
|
|
|
// returns a time to exit from the zone
|
|
auto timeFrom(this auto&& self, mcc_mount_telemetry_data_c auto const& telemetry_data)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::timeFrom method");
|
|
} else {
|
|
return std::forward<self_t>(self).timeFrom(telemetry_data);
|
|
}
|
|
}
|
|
|
|
auto timeFrom(this auto&& self, mcc_celestial_point_c auto const& sky_point)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPzoneAbstractInterface>) {
|
|
static_assert(false, "Call an empty MccPzoneAbstractInterface::timeFrom method");
|
|
} else {
|
|
return std::forward<self_t>(self).timeFrom(sky_point);
|
|
}
|
|
}
|
|
};
|
|
|
|
template <typename T, typename TelemetryDataT>
|
|
concept mcc_prohibited_zone_c =
|
|
mcc_mount_telemetry_data_c<TelemetryDataT> && std::movable<T> && requires(T t, const T t_const) {
|
|
typename T::coord_t;
|
|
// typename T::time_point_t;
|
|
requires mcc_time_duration_c<typename T::duration_t>;
|
|
|
|
// static constexpr member to represent infinite duration
|
|
requires requires {
|
|
requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t const>;
|
|
[]() {
|
|
constexpr auto val = T::infiniteDuration;
|
|
return val;
|
|
};
|
|
};
|
|
|
|
// static constexpr member to represent zero duration
|
|
requires requires {
|
|
requires std::same_as<decltype(T::zeroDuration), typename T::duration_t const>;
|
|
[]() {
|
|
constexpr auto val = T::zeroDuration;
|
|
return val;
|
|
};
|
|
};
|
|
|
|
|
|
// return a name of the zone
|
|
{ t_const.name() } -> mcc_formattable;
|
|
|
|
|
|
// check if given coordinates are into the zone.
|
|
{ t.inZone(std::declval<const TelemetryDataT&>()) } -> std::convertible_to<bool>;
|
|
|
|
// a time duration to reach the zone.
|
|
// special values the method must return:
|
|
// 'infiniteDuration' if the given sky point never reaches the zone
|
|
// 0 (zero duration) if the given sky point is already in the zone or it never exits from the zone
|
|
{ t.timeTo(std::declval<const TelemetryDataT&>()) } -> std::same_as<typename T::duration_t>;
|
|
|
|
// a time duration to exit from the zone.
|
|
// special values the method must return:
|
|
// 0 (zero duration) if the given sky point already exited from the zone or it never reaches the zone
|
|
{ t.timeFrom(std::declval<const TelemetryDataT&>()) } -> std::same_as<typename T::duration_t>;
|
|
};
|
|
|
|
// an input range of prohibited zones
|
|
template <typename T, typename TelemetryDataT>
|
|
concept mcc_irange_of_pzones_c = mcc_mount_telemetry_data_c<TelemetryDataT> && std::ranges::input_range<T> &&
|
|
mcc_prohibited_zone_c<std::ranges::range_value_t<T>, TelemetryDataT>;
|
|
|
|
|
|
// // a concept for a callable with the first argument of type satisfied to 'mcc_prohibited_zone_c'
|
|
// template <typename T, typename TelemetryDataT>
|
|
// concept mcc_pzone_foreach_func_c = mcc_is_callable<T> && mcc_mount_telemetry_data_c<TelemetryDataT> &&
|
|
// mcc_prohibited_zone_c<mcc_func_arg1_t<T>, TelemetryDataT>;
|
|
|
|
|
|
// There is no way to declare a concept of class with templated method so one needs to define
|
|
// a generic interface of prohibited zones holder/container explicitly
|
|
template <mcc_mount_telemetry_data_c TelemetryDataT>
|
|
struct MccPZoneAbstractContainer {
|
|
virtual ~MccPZoneAbstractContainer() = default;
|
|
|
|
// must return a size of the container after the addition of the given zone
|
|
template <mcc_prohibited_zone_c<TelemetryDataT> ZT>
|
|
size_t pzAddZone(this auto&& self, ZT zone)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzAddZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzAddZone(std::move(zone));
|
|
}
|
|
}
|
|
|
|
// clear the container
|
|
auto pzClearZones(this auto&& self)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzClearZones method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzClearZones();
|
|
}
|
|
}
|
|
|
|
// must return the size of the container (number of zones)
|
|
size_t pzSize(this auto&& self)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzSize method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzSize();
|
|
}
|
|
}
|
|
|
|
|
|
// must return true if the given telemetry coordinates are in any of zones in the container and
|
|
// false otherwise
|
|
template <typename RT>
|
|
bool pzInZone(this auto&& self, const TelemetryDataT& tdata, RT& result)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzInZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzInZone(tdata, result);
|
|
}
|
|
}
|
|
|
|
template <typename RT>
|
|
auto pzTimeTo(this auto&& self, const TelemetryDataT& tdata, RT& result)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzInZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzTimeTo(tdata, result);
|
|
}
|
|
}
|
|
|
|
template <typename RT>
|
|
auto pzTimeFrom(this auto&& self, const TelemetryDataT& tdata, RT& result)
|
|
{
|
|
using self_t = decltype(self);
|
|
|
|
if constexpr (std::same_as<std::remove_cvref_t<self_t>, MccPZoneAbstractContainer>) {
|
|
static_assert(false, "Call an empty MccPZoneAbstractContainer::pzInZone method");
|
|
} else {
|
|
return std::forward<self_t>(self).pzTimeFrom(tdata, result);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
MccPZoneAbstractContainer() = default;
|
|
};
|
|
|
|
// a full concept for prohibited zones container
|
|
template <typename T, typename TelemetryDataT>
|
|
concept mcc_mount_pzones_container_c = std::derived_from<T, MccPZoneAbstractContainer<TelemetryDataT>> && requires {
|
|
// common time duration type for zones 'timeTo' and 'timeFrom' methods
|
|
requires mcc_time_duration_c<typename T::duration_t>;
|
|
|
|
// static constexpr member to represent infinite duration
|
|
requires requires {
|
|
requires std::same_as<decltype(T::infiniteDuration), typename T::duration_t const>;
|
|
[]() {
|
|
constexpr auto val = T::infiniteDuration;
|
|
return val;
|
|
};
|
|
};
|
|
|
|
// static constexpr member to represent zero duration
|
|
requires requires {
|
|
requires std::same_as<decltype(T::zeroDuration), typename T::duration_t const>;
|
|
[]() {
|
|
constexpr auto val = T::zeroDuration;
|
|
return val;
|
|
};
|
|
};
|
|
};
|
|
|
|
/* MOUNT GENERIC CONTROLS */
|
|
|
|
|
|
template <typename T>
|
|
concept mcc_mount_controls_c = requires(T t) {
|
|
// concept mcc_mount_controls_c = std::move_constructible<T> && std::movable<T> && requires(T t) {
|
|
requires mcc_astrom_engine_c<decltype(t.astrometryEngine)>;
|
|
requires mcc_mount_pec_c<decltype(t.PEC)>;
|
|
requires mcc_mount_hardware_c<decltype(t.hardware)>;
|
|
requires mcc_mount_telemetry_c<decltype(t.telemetry)>;
|
|
|
|
requires mcc_slew_model_c<decltype(t.slewModel)>;
|
|
requires mcc_guiding_model_c<decltype(t.guidingModel)>;
|
|
|
|
// a std::tuple of prohibited zones
|
|
// []<mcc_prohibited_zone_c<typename decltype(t.telemetry)::mount_telemetry_data_t>... Ts>(std::tuple<Ts...>) {
|
|
// }(t.prohibitedZones);
|
|
|
|
// requires mcc_tuple_c<decltype(t.prohibitedZones)>;
|
|
requires mcc_irange_of_pzones_c<decltype(t.prohibitedZones),
|
|
typename decltype(t.telemetry)::mount_telemetry_data_t>;
|
|
};
|
|
|
|
|
|
/* GENERIC MOUNT CONCEPTS */
|
|
|
|
template <typename T>
|
|
concept mcc_mount_c = requires(T t) {
|
|
// the class must define typename 'mount_controls_t' and it must be its base class
|
|
requires mcc_mount_controls_c<typename T::mount_controls_t>;
|
|
requires std::derived_from<T, typename T::mount_controls_t>;
|
|
|
|
|
|
// deduced from 'mount_controls_t' typenames
|
|
requires mcc_mount_telemetry_c<typename T::mount_telemetry_t>;
|
|
requires std::same_as<typename T::mount_telemetry_data_t, typename T::mount_telemetry_t::mount_telemetry_data_t>;
|
|
requires mcc_astrom_engine_c<typename T::astrom_engine_t>;
|
|
requires mcc_mount_pec_c<typename T::pec_t>;
|
|
requires mcc_mount_hardware_c<typename T::hardware_t>;
|
|
requires mcc_slew_model_c<typename T::slew_model_t>;
|
|
requires mcc_guiding_model_c<typename T::guiding_model_t>;
|
|
|
|
// public methods
|
|
{
|
|
t.mountTelemetryData(std::declval<typename T::mount_telemetry_data_t&>())
|
|
} -> std::same_as<typename T::mount_telemetry_t::error_t>;
|
|
|
|
{
|
|
t.slewMount(std::declval<typename T::slew_model_t::slew_point_t>())
|
|
} -> std::same_as<typename T::slew_model_t::error_t>;
|
|
|
|
{
|
|
t.guidingTarget(std::declval<typename T::guiding_model_t::guiding_point_t>())
|
|
} -> std::same_as<typename T::guiding_model_t::error_t>;
|
|
};
|
|
|
|
// generic with public logging methods
|
|
template <typename T>
|
|
concept mcc_log_mount_c = mcc_mount_c<T> && mcc_logger_c<T>;
|
|
|
|
|
|
// a generic Finite State Machine mount with logging methods
|
|
template <typename T>
|
|
concept mcc_fsm_log_mount_c = std::derived_from<T, fsm::MccFiniteStateMachine> && mcc_log_mount_c<T>;
|
|
|
|
} // namespace mcc::traits
|
|
|
|
|
|
|
|
/* CHECK LIBRARY-WIDE CLASS DECLARATIONS FOR ITS CONCEPTS SATISFACTION */
|
|
|
|
namespace mcc
|
|
{
|
|
|
|
static_assert(traits::mcc_logger_c<MccNullLogger>, "MccNullLogger INVALID DECLARATION!");
|
|
|
|
} // namespace mcc
|